add tools/Vulkan-Tools

130 files changed, 73956 insertions, 0 deletions

diff --git a/tools/Vulkan-Tools/.clang-format b/tools/Vulkan-Tools/.clang-format
new file mode 100644
index 00000000..453527f9
--- /dev/null
+++ b/tools/Vulkan-Tools/.clang-format
@@ -0,0 +1,8 @@
+---
+# Use defaults from the Google style with the following exceptions:
+BasedOnStyle: Google
+IndentWidth: 4
+AccessModifierOffset: -2
+ColumnLimit: 132
+SortIncludes: false
+...
diff --git a/tools/Vulkan-Tools/.gitattributes b/tools/Vulkan-Tools/.gitattributes
new file mode 100644
index 00000000..1687690d
--- /dev/null
+++ b/tools/Vulkan-Tools/.gitattributes
@@ -0,0 +1,20 @@
+# See https://git-scm.com/docs/gitattributes
+# See https://help.github.com/articles/dealing-with-line-endings/
+
+# Default behavior, if core.autocrlf is unset.
+* text=auto
+
+# Files to be converted to native line endings on checkout.
+*.cpp text
+*.h text
+
+# Text files to always have CRLF (dos) line endings on checkout.
+*.bat text eol=crlf
+
+# Text files to always have LF (unix) line endings on checkout.
+*.sh text eol=lf
+
+# Generated source files will always have LF (unix) line endings on checkout.
+icd/generated/*.cpp text eol=lf
+icd/generated/*.h text eol=lf
+vulkaninfo/generated/*.hpp text eol=lf
diff --git a/tools/Vulkan-Tools/.github/dependabot.yml b/tools/Vulkan-Tools/.github/dependabot.yml
new file mode 100644
index 00000000..ae4d17d1
--- /dev/null
+++ b/tools/Vulkan-Tools/.github/dependabot.yml
@@ -0,0 +1,12 @@
+# ~~~
+# Copyright 2023 LunarG, Inc.
+#
+# SPDX-License-Identifier: Apache-2.0
+# ~~~
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 3
\ No newline at end of file
diff --git a/tools/Vulkan-Tools/.github/workflows/tools.yml b/tools/Vulkan-Tools/.github/workflows/tools.yml
new file mode 100644
index 00000000..6a11a043
--- /dev/null
+++ b/tools/Vulkan-Tools/.github/workflows/tools.yml
@@ -0,0 +1,242 @@
+# Copyright (c) 2021-2024 Valve Corporation
+# Copyright (c) 2021-2024 LunarG, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+name: tools
+
+on:
+    push:
+    pull_request:
+        branches:
+            - main
+
+# https://docs.github.com/en/actions/using-jobs/using-concurrency
+concurrency:
+  # github.head_ref is only defined on pull_request
+  # Fallback to the run ID, which is guaranteed to be both unique and defined for the run.
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id  }}
+  cancel-in-progress: true
+
+jobs:
+    linux:
+        needs: tools_codegen
+        runs-on: ${{matrix.os}}
+        if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
+        strategy:
+            matrix:
+                cc: [ gcc ]
+                cxx: [ g++ ]
+                config: [ Debug, Release ]
+                os: [ ubuntu-22.04, ubuntu-22.04 ]
+                include:
+                    # Test clang on ubuntu 22
+                  - cc: clang
+                    cxx: clang++
+                    config: Debug
+                    os: ubuntu-22.04
+                    # Test clang on ubuntu 24
+                  - cc: clang
+                    cxx: clang++
+                    config: Release
+                    os: ubuntu-24.04
+
+
+        steps:
+            - uses: actions/checkout@v6
+            - run: |
+                sudo apt-get -qq update
+                sudo apt install --yes libwayland-dev xorg-dev wayland-protocols
+            - uses: lukka/get-cmake@latest
+              with:
+                cmakeVersion: 3.22.1
+            - name: Setup ccache
+              uses: hendrikmuhs/ccache-action@v1.2
+              with:
+                key: ${{ runner.os }}-${{ matrix.config }}-${{ matrix.cc }}
+            # This is to combat a bug when using 6.6 linux kernels with thread/address sanitizer
+            # https://github.com/google/sanitizers/issues/1716
+            - run: sudo sysctl vm.mmap_rnd_bits=28
+            - name: Configure
+              run: |
+                cmake -S. -B build -G "Ninja" \
+                -D CMAKE_BUILD_TYPE=${{matrix.config}} \
+                -D UPDATE_DEPS=ON \
+                -D BUILD_WERROR=ON \
+                -D INSTALL_ICD=ON \
+                -D BUILD_TESTS=ON \
+                -D ENABLE_ADDRESS_SANITIZER=ON
+              env:
+                CC: ${{matrix.cc}}
+                CXX: ${{matrix.cxx}}
+                CMAKE_CXX_COMPILER_LAUNCHER: ccache
+                CMAKE_C_COMPILER_LAUNCHER: ccache
+
+            - name: Build
+              run: cmake --build build
+
+            - name: Install
+              run: cmake --install build/ --prefix build/install
+
+            - name: Test
+              working-directory: ./build
+              run: ctest --output-on-failure
+
+    codegen:
+      runs-on: ubuntu-latest
+      steps:
+        - uses: actions/checkout@v6
+        - run: scripts/update_deps.py --dir ext --no-build
+        - run: scripts/generate_source.py --verify ext/Vulkan-Headers/registry/
+
+    windows:
+        needs: tools_codegen
+        runs-on: ${{matrix.os}}
+        if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
+
+        strategy:
+            matrix:
+                arch: [ Win32, x64 ]
+                config: [ Debug, Release ]
+                os: [ windows-latest ]
+
+        steps:
+            - uses: actions/checkout@v6
+            - uses: lukka/get-cmake@latest
+            - uses: ilammy/msvc-dev-cmd@v1
+              with:
+                arch: ${{ matrix.arch }}
+
+            - name: Configure
+              run: cmake -S. -B build -G "Ninja" -DCMAKE_BUILD_TYPE=${{matrix.config}} -D UPDATE_DEPS=ON -D INSTALL_ICD=ON -D BUILD_TESTS=ON -D BUILD_WERROR=ON
+
+            - name: Build
+              run: cmake --build ./build
+
+            - name: Install
+              run: cmake --install build/ --prefix build/install
+
+            - name: Test
+              working-directory: ./build
+              run: ctest --output-on-failure
+
+    mac:
+        # mac is 10x expensive to run on GitHub machines, so only run if we know something else fast/simple passed as well
+        needs: chromium
+        runs-on: macos-latest
+        if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
+        steps:
+            - uses: actions/checkout@v6
+            - uses: lukka/get-cmake@latest
+
+            - name: Setup ccache
+              uses: hendrikmuhs/ccache-action@v1.2
+              with:
+                key: macos
+
+            # NOTE: Add ccache this way instead of with CMAKE_<LANG>_COMPILER_LAUNCHER since MoltenVK doesn't use CMake.
+            - name: Add ccache to PATH
+              run: echo "/usr/lib/ccache:/usr/local/opt/ccache/libexec" >> $GITHUB_PATH
+
+            - run: cmake -S. -B build -G Ninja -DCMAKE_BUILD_TYPE=Release -D UPDATE_DEPS=ON -D INSTALL_ICD=ON -D BUILD_TESTS=ON -D ENABLE_ADDRESS_SANITIZER=ON -D BUILD_WERROR=OFF # Disable warnings as unavoidable deprecation notice causes CI to fail
+
+            - run: cmake --build build
+
+            - run: ctest --output-on-failure --test-dir build/
+
+            - run: cmake --install build --prefix /tmp
+
+    android:
+      needs: tools_codegen
+      runs-on: ubuntu-22.04
+      if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
+      strategy:
+        matrix:
+          abi: [ armeabi-v7a, arm64-v8a ]
+      steps:
+        - uses: actions/checkout@v6
+        - uses: actions/setup-python@v6
+          with:
+            python-version: '3.8'
+        - uses: lukka/get-cmake@latest
+        - name: Configure
+          run: |
+            cmake -S . -B build/ --toolchain $ANDROID_NDK_ROOT/build/cmake/android.toolchain.cmake \
+            -D ANDROID_PLATFORM=23 \
+            -D CMAKE_ANDROID_ARCH_ABI=${{matrix.abi}} \
+            -D CMAKE_ANDROID_STL_TYPE=c++_static \
+            -D ANDROID_USE_LEGACY_TOOLCHAIN_FILE=NO \
+            -D CMAKE_BUILD_TYPE=Release \
+            -D UPDATE_DEPS=ON \
+            -D BUILD_TESTS=ON \
+            -D BUILD_WERROR=ON \
+            -G "Ninja"
+        - name: Build
+          run: cmake --build build
+        - name: Test
+          working-directory: ./build
+          run: ctest --output-on-failure -C Release
+        - name: Install
+          run: cmake --install build --prefix /tmp
+
+    mingw:
+        needs: tools_codegen
+        if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
+        runs-on: windows-latest
+        defaults:
+          run:
+            shell: bash
+        steps:
+          - uses: actions/checkout@v6
+          - name: Setup ccache
+            uses: hendrikmuhs/ccache-action@v1.2
+            with:
+              key: mingw-ccache
+          - uses: lukka/get-cmake@latest
+          - name: GCC Version
+            run: gcc --version # If this fails MINGW is not setup correctly
+          - name: Configure
+            run: cmake -S. -B build -D UPDATE_DEPS=ON -D CMAKE_BUILD_TYPE=Release
+            env:
+              LDFLAGS: -fuse-ld=lld # MINGW linking is very slow. Use llvm linker instead.
+              CMAKE_C_COMPILER_LAUNCHER: ccache
+              CMAKE_CXX_COMPILER_LAUNCHER: ccache
+              CMAKE_GENERATOR: Ninja
+          - run: cmake --build build
+          - run: cmake --install build --prefix build/install
+
+    tools_codegen:
+      needs: codegen
+      if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
+      runs-on: ubuntu-latest
+      steps:
+        - uses: actions/checkout@v6
+        - uses: actions/setup-python@v6
+          with:
+            python-version: '3.10'
+        - run: pip install pyparsing
+        - run: sudo apt-get -qq update && sudo apt install --yes libwayland-dev xorg-dev wayland-protocols
+        - run: cmake -S . -B build/ -D UPDATE_DEPS=ON -D UPDATE_DEPS_DIR=external -D TOOLS_CODEGEN=ON
+        - run: cmake --build build --target tools_codegen
+        - run: git diff --exit-code
+
+    chromium:
+      needs: tools_codegen
+      if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
+      runs-on: ubuntu-latest
+      steps:
+        - uses: actions/checkout@v6
+        - uses: actions/setup-python@v6
+          with:
+            python-version: '3.10'
+        - run: scripts/gn/gn.py
diff --git a/tools/Vulkan-Tools/.gitignore b/tools/Vulkan-Tools/.gitignore
new file mode 100644
index 00000000..fb4c8667
--- /dev/null
+++ b/tools/Vulkan-Tools/.gitignore
@@ -0,0 +1,47 @@
+# By default we install dependencies to the external directory
+/external/*
+
+# Ignore any build directories
+*build*/
+
+CMakeCache.txt
+CMakeLists.txt.user
+CMakeUserPresets.json
+CMakeFiles/
+cmake_install.cmake
+Makefile
+glslang/*
+scripts/__pycache__
+*.so
+*.so.*
+_out64
+out32/*
+out64/*
+*.pyc
+*.vcproj
+*.sln
+*.suo
+*.vcxproj
+*.sdf
+*.filters
+*.config
+*.creator
+*.creator.user
+*.files
+*.includes
+.vscode/
+.DS_Store
+.cache
+
+# Chromium build artifacts
+.cipd/
+.gn
+.gclient
+.gclient_entries
+.gclient_previous_sync_commits
+out/
+third_party/
+buildtools/
+depot_tools/
+testing/
+tools/
diff --git a/tools/Vulkan-Tools/BUILD.gn b/tools/Vulkan-Tools/BUILD.gn
new file mode 100644
index 00000000..08bd22a1
--- /dev/null
+++ b/tools/Vulkan-Tools/BUILD.gn
@@ -0,0 +1,92 @@
+# Copyright (C) 2018-2019 The ANGLE Project Authors.
+# Copyright (C) 2019-2023 LunarG, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//build_overrides/build.gni")
+import("//build_overrides/vulkan_tools.gni")
+
+if (!is_android) {
+  vulkan_undefine_configs = []
+  if (is_win && build_with_chromium) {
+    vulkan_undefine_configs += [
+      "//build/config/win:nominmax",
+      "//build/config/win:unicode",
+    ]
+  }
+
+  # Vulkan Mock ICD
+  # ---------------
+  shared_library("VkICD_mock_icd") {
+    configs -= vulkan_undefine_configs
+    deps = [
+      "$vulkan_headers_dir:vulkan_headers"
+    ]
+    data_deps = [ ":vulkan_gen_icd_json_file" ]
+    sources = [
+      "icd/mock_icd.h",
+      "icd/mock_icd.cpp",
+      "icd/generated/function_declarations.h",
+      "icd/generated/function_definitions.h",
+      "icd/generated/vk_typemap_helper.h",
+    ]
+    include_dirs = [
+        "icd",
+        "icd/generated",
+    ]
+    if (is_win) {
+      sources += [ "icd/VkICD_mock_icd.def" ]
+    }
+    if (build_with_chromium) {
+      configs -= [ "//build/config/compiler:chromium_code" ]
+      configs += [ "//build/config/compiler:no_chromium_code" ]
+    }
+  }
+
+  action("vulkan_gen_icd_json_file") {
+    script = "scripts/gn/generate_vulkan_icd_json.py"
+
+    public_deps = [ "$vulkan_headers_dir:vulkan_headers" ]
+
+    sources = [  "icd/VkICD_mock_icd.json.in" ]
+
+    vulkan_data_dir = "$root_out_dir/$vulkan_data_subdir"
+
+    outputs = [ "$vulkan_data_dir/VkICD_mock_icd.json" ]
+
+    if (is_linux) {
+      _platform = "Linux"
+    } else if (is_win) {
+      _platform = "Windows"
+    } else if (is_mac) {
+      _platform = "Darwin"
+    } else if (is_fuchsia) {
+      _platform = "Fuchsia"
+    } else {
+      _platform = "Other"
+    }
+
+    args =  [
+      "--icd",
+      "--platform", _platform,
+      rebase_path("icd/", root_build_dir),
+      rebase_path(vulkan_data_dir, root_build_dir)
+    ] + rebase_path(sources, root_build_dir)
+
+    if (is_win) {
+      args += [ "--no-path-prefix" ]
+    }
+
+    data = outputs
+  }
+}
diff --git a/tools/Vulkan-Tools/BUILD.md b/tools/Vulkan-Tools/BUILD.md
new file mode 100644
index 00000000..ef643502
--- /dev/null
+++ b/tools/Vulkan-Tools/BUILD.md
@@ -0,0 +1,324 @@
+# Build Instructions
+
+1. [Requirements](#requirements)
+1. [Building Overview](#building-overview)
+1. [Generated source code](#generated-source-code)
+1. [Dependencies](#dependencies)
+1. [Linux Build](#building-on-linux)
+1. [Windows Build](#building-on-windows)
+1. [MacOS build](#building-on-macos)
+1. [Android Build](#building-for-android)
+1. [Installed Files](#installed-files)
+
+## Requirements
+
+1. CMake >= 3.22.1
+1. C++17 compatible toolchain
+1. Git
+1. Python >= 3.10
+
+NOTE: Python is needed for working on generated code, and helping grab dependencies.
+While it's not technically required, it's practically required for most users.
+
+### Generated source code
+
+This repository contains generated source code which is not intended to be modified directly.
+
+A helper CMake target `tools_codegen` is also provided to simplify the invocation of `scripts/generate_source.py` from the build directory:
+
+```bash
+cmake -S . -B build -D TOOLS_CODEGEN=ON
+cmake --build build --target tools_codegen
+```
+
+NOTE: `TOOLS_CODEGEN` is `OFF` by default.
+
+## Building Overview
+
+The following will be enough for most people, for more detailed instructions, see below.
+
+```bash
+git clone https://github.com/KhronosGroup/Vulkan-Tools.git
+cd Vulkan-Tools
+
+cmake -S . -B build -D UPDATE_DEPS=ON -D BUILD_WERROR=ON -D BUILD_TESTS=ON -D CMAKE_BUILD_TYPE=Debug
+cmake --build build --config Debug
+```
+
+### Warnings as errors off by default!
+
+By default `BUILD_WERROR` is `OFF`. The idiom for open source projects is to NOT enable warnings as errors.
+
+System/language package managers have to build on multiple different platforms and compilers.
+
+By defaulting to `ON` we cause issues for package managers since there is no standard way to disable warnings until CMake 3.24
+
+Add `-D BUILD_WERROR=ON` to your workflow. Or use the `dev` preset shown below which will also enabling warnings as errors.
+
+## Dependencies
+
+Currently this repo has a custom process for grabbing C/C++ dependencies.
+
+Keep in mind this repo predates tools like `vcpkg`, `conan`, etc. Our process is most similar to `vcpkg`.
+
+By specifying `-D UPDATE_DEPS=ON` when configuring CMake we grab dependencies listed in [known_good.json](scripts/known_good.json).
+
+All we are doing is streamlining `building`/`installing` the `known good` dependencies and helping CMake `find` the dependencies.
+
+This is done via a combination of `Python` and `CMake` scripting.
+
+Misc Useful Information:
+
+- By default `UPDATE_DEPS` is `OFF`. The intent is to be friendly by default to system/language package managers.
+- You can run `update_deps.py` manually but it isn't recommended for most users.
+
+### How to test new dependency versions
+
+Typically most developers alter `known_good.json` with the commit/branch they are testing.
+
+Alternatively you can modify `CMAKE_PREFIX_PATH` as follows.
+
+```sh
+# Delete the CMakeCache.txt which will cache find_* results
+rm  -rf build/
+cmake -S . -B build/ ... -D CMAKE_PREFIX_PATH=~/foobar/vulkan_headers_install/ ...
+```
+
+## Building On Linux
+
+### Linux Build Requirements
+
+This repository is regularly built and tested on the two most recent Ubuntu LTS versions.
+
+```bash
+sudo apt-get install git build-essential python3 cmake
+
+# Linux WSI system libraries
+sudo apt-get install libwayland-dev xorg-dev
+```
+
+### WSI Support Build Options
+
+By default, the repository components are built with support for the
+Vulkan-defined WSI display servers: Xcb, Xlib, and Wayland. It is recommended
+to build the repository components with support for these display servers to
+maximize their usability across Linux platforms. If it is necessary to build
+these modules without support for one of the display servers, the appropriate
+CMake option of the form `BUILD_WSI_xxx_SUPPORT` can be set to `OFF`.
+
+### Linux 32-bit support
+
+Usage of this repository's contents in 32-bit Linux environments is not
+officially supported. However, since this repository is supported on 32-bit
+Windows, these modules should generally work on 32-bit Linux.
+
+Here are some notes for building 32-bit targets on a 64-bit Ubuntu "reference"
+platform:
+
+```bash
+# 32-bit libs
+# your PKG_CONFIG configuration may be different, depending on your distribution
+sudo apt-get install gcc-multilib g++-multilib libx11-dev:i386
+```
+
+Set up your environment for building 32-bit targets:
+
+```bash
+export ASFLAGS=--32
+export CFLAGS=-m32
+export CXXFLAGS=-m32
+export PKG_CONFIG_LIBDIR=/usr/lib/i386-linux-gnu
+```
+
+## Building On Windows
+
+### Windows Development Environment Requirements
+
+- Windows 10+
+- Visual Studio
+
+Note: Anything less than `Visual Studio 2019` is not guaranteed to compile/work.
+
+### Visual Studio Generator
+
+Run CMake to generate [Visual Studio project files](https://cmake.org/cmake/help/latest/guide/user-interaction/index.html#command-line-g-option).
+
+```bash
+# NOTE: By default CMake picks the latest version of Visual Studio as the default generator.
+cmake -S . -B build
+
+# Open the Visual Studio solution
+cmake --open build
+```
+
+See the [CMake documentation](https://cmake.org/cmake/help/latest/manual/cmake-generators.7.html#visual-studio-generators) for further information on Visual Studio generators.
+
+NOTE: Windows developers don't have to develop in Visual Studio. Visual Studio just helps streamlining the needed C++ toolchain requirements (compilers, linker, etc).
+
+## Building on MacOS
+
+### MacOS Development Environment Requirements
+
+- Xcode
+
+NOTE: MacOS developers don't have to develop in Xcode. Xcode just helps streamlining the needed C++ toolchain requirements (compilers, linker, etc). Similar to Visual Studio on Windows.
+
+### Xcode Generator
+
+To create and open an Xcode project:
+
+```bash
+# Create the Xcode project
+cmake -S . -B build -G Xcode
+
+# Open the Xcode project
+cmake --open build
+```
+
+See the [CMake documentation](https://cmake.org/cmake/help/latest/generator/Xcode.html) for further information on the Xcode generator.
+
+## Building For Android
+
+- CMake 3.22.1+
+- NDK r25+
+- Ninja 1.10+
+- Android SDK Build-Tools 34.0.0+
+
+### Android Build Requirements
+
+- Download [Android Studio](https://developer.android.com/studio)
+- Install (https://developer.android.com/studio/install)
+- From the `Welcome to Android Studio` splash screen, add the following components using the SDK Manager:
+  - SDK Platforms > Android 8.0 and newer (API Level 26 or higher)
+  - SDK Tools > Android SDK Build-Tools
+  - SDK Tools > Android SDK Platform-Tools
+  - SDK Tools > Android SDK Tools
+  - SDK Tools > NDK
+  - SDK Tools > CMake
+
+#### Add Android specifics to environment
+
+NOTE: The following commands are streamlined for Linux but easily transferable to other platforms.
+The main intent is setting 2 environment variables and ensuring the NDK and build tools are in the `PATH`.
+
+```sh
+# Set environment variables
+# https://github.com/actions/runner-images/blob/main/images/linux/Ubuntu2204-Readme.md#environment-variables-2
+export ANDROID_SDK_ROOT=$HOME/Android/Sdk
+export ANDROID_NDK_HOME=$ANDROID_SDK_ROOT/ndk/X.Y.Z
+
+# Modify path
+export PATH=$ANDROID_SDK_ROOT/build-tools/X.Y.Z:$PATH
+
+# (Optional if you have new enough version of CMake + Ninja)
+export PATH=$ANDROID_SDK_ROOT/cmake/3.22.1/bin:$PATH
+
+# Verify SDK build-tools is set correctly
+which aapt
+
+# Verify CMake/Ninja are in the path
+which cmake
+which ninja
+
+# Check apksigner
+apksigner --help
+```
+
+Note: If `apksigner` gives a `java: not found` error you do not have Java in your path.
+
+```bash
+# A common way to install on the system
+sudo apt install default-jre
+```
+
+### Android Build
+
+1. Building the binaries (No APK)
+
+Invoking CMake directly to build the binary is relatively simple.
+
+See https://developer.android.com/ndk/guides/cmake#command-line for CMake NDK documentation.
+
+```sh
+# Build release binary for arm64-v8a
+cmake -S . -B build \
+  -D CMAKE_TOOLCHAIN_FILE=$ANDROID_NDK_HOME/build/cmake/android.toolchain.cmake \
+  -D ANDROID_PLATFORM=26 \
+  -D CMAKE_ANDROID_ARCH_ABI=arm64-v8a \
+  -D CMAKE_ANDROID_STL_TYPE=c++_static \
+  -D ANDROID_USE_LEGACY_TOOLCHAIN_FILE=NO \
+  -D CMAKE_BUILD_TYPE=Release \
+  -D UPDATE_DEPS=ON \
+  -G Ninja
+
+cmake --build build
+
+cmake --install build --prefix build/install
+```
+
+Alternatively users can also use `scripts/android.py` to build the binaries.
+
+```sh
+# Build release binaries for arm64-v8a
+python3 scripts/android.py --config Release --app-abi arm64-v8a --app-stl c++_static
+```
+
+`android.py` can also streamline building for multiple ABIs:
+
+```sh
+# Build release binaries for all ABIs
+python3 scripts/android.py --config Release --app-abi 'armeabi-v7a arm64-v8a x86 x86_64' --app-stl c++_static
+```
+
+NOTE: The above methods will only build the `vulkaninfo` and `libVkCube`. It won't create an APK.
+
+Furthermore `vulkaninfo` is intended to run as an executable (No APK).
+
+2. Building the VkCube APK
+
+Creating the `VkCube.apk` is a bit of an involved process since it requires running multiple CLI tools after the CMake build has finished.
+
+As a result users are enouraged to use `scripts/android.py` to build the APK.
+
+This script handles wrapping CMake and various Android CLI tools to create the APK for you.
+
+```sh
+# Build a complete APK with debug binaries for all ABIS
+python3 scripts/android.py --config Debug --app-abi 'armeabi-v7a arm64-v8a x86 x86_64' --app-stl c++_shared --apk
+
+# Build a clean APK with release binaries for arm64-v8a
+python3 scripts/android.py --config Release --app-abi arm64-v8a --app-stl c++_shared --apk --clean
+```
+
+Note: `scripts/android.py` will place the APK in the `build-android/bin` directory.
+
+See [tests/README.md](tests/README.md) for running `VkCube.apk` / `vulkaninfo` on Android.
+
+### Installed Files
+
+- *install_dir*`/bin` : The `vulkaninfo`, `vkcube` and `vkcubepp` executables
+
+If `INSTALL_ICD` is configured then MockICD will be installed as follows:
+
+For Unix operating systems:
+
+- *install_dir*`/bin` : The Mock ICD
+- *install_dir*`/share/vulkan/icd.d` : Mock ICD JSON
+
+For WIN32:
+
+- *install_dir*`/bin` : The Mock ICD and JSON
+
+### Software Installation
+
+After you have built your project you can install using CMake's install functionality.
+
+CMake Docs:
+- [Software Installation Guide](https://cmake.org/cmake/help/latest/guide/user-interaction/index.html#software-installation)
+- [CLI for installing a project](https://cmake.org/cmake/help/latest/manual/cmake.1.html#install-a-project)
+
+```sh
+# EX: Installs Release artifacts into `build/install` directory.
+# NOTE: --config is only needed for multi-config generators (Visual Studio, Xcode, etc)
+cmake --install build/ --config Release --prefix build/install
+```
diff --git a/tools/Vulkan-Tools/CMakeLists.txt b/tools/Vulkan-Tools/CMakeLists.txt
new file mode 100644
index 00000000..6800d4f8
--- /dev/null
+++ b/tools/Vulkan-Tools/CMakeLists.txt
@@ -0,0 +1,155 @@
+# ~~~
+# Copyright (c) 2014-2023 Valve Corporation
+# Copyright (c) 2014-2023 LunarG, Inc.
+# Copyright (c) 2023-2023 RasterGrid Kft.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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.22.1)
+
+# The VERSION field is generated with the "--generated-version" flag in the generate_source.py script
+project(Vulkan-Tools VERSION 1.4.347)
+
+# This variable enables downstream users to customize the target API
+# variant (e.g. Vulkan SC)
+set(API_TYPE "vulkan")
+
+add_subdirectory(scripts)
+
+set(CMAKE_CXX_VISIBILITY_PRESET "hidden")
+set(CMAKE_C_VISIBILITY_PRESET "hidden")
+set(CMAKE_VISIBILITY_INLINES_HIDDEN "YES")
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_C_STANDARD 99)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+set(CMAKE_C_EXTENSIONS OFF)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+option(BUILD_CUBE "Build cube" ON)
+option(BUILD_VULKANINFO "Build vulkaninfo" ON)
+option(BUILD_ICD "Build icd" ON)
+option(BUILD_TESTS "Build the tests")
+option(BUILD_WERROR "Treat compiler warnings as errors")
+# NOTE: Our custom code generation target isn't desirable for system package managers or add_subdirectory users.
+# So this target needs to be off by default to avoid obtuse build errors or patches.
+option(TOOLS_CODEGEN "Enable helper codegen target")
+
+option(ENABLE_ADDRESS_SANITIZER "Use address sanitization")
+if (ENABLE_ADDRESS_SANITIZER)
+    add_compile_options(-fsanitize=address)
+    if (NOT MSVC)
+        add_link_options(-fsanitize=address)
+    endif()
+endif()
+
+set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+
+find_package(VulkanHeaders ${PROJECT_VERSION} QUIET REQUIRED CONFIG)
+if ((APPLE OR BUILD_TESTS) AND NOT ANDROID)
+    find_package(VulkanLoader QUIET REQUIRED CONFIG)
+endif()
+
+include(GNUInstallDirs)
+
+if (BUILD_WERROR)
+    add_compile_options("$<IF:$<CXX_COMPILER_ID:MSVC>,/WX,-Werror>")
+endif()
+
+if (${CMAKE_CXX_COMPILER_ID} MATCHES "(GNU|Clang)")
+    add_compile_options(
+        -Wall
+        -Wextra
+        -Wno-unused-parameter
+        -Wno-missing-field-initializers
+    )
+
+    if (${CMAKE_CXX_COMPILER_ID} MATCHES "GNU")
+        add_compile_options(-Wno-stringop-truncation)
+    endif()
+
+    if (${CMAKE_CXX_COMPILER_ID} MATCHES "Clang")
+        add_compile_options(
+            -Wno-sign-conversion
+            -Wno-shorten-64-to-32
+            -Wno-string-conversion
+            -Wno-implicit-int-conversion
+            -Wno-enum-enum-conversion
+        )
+    endif()
+elseif(MSVC)
+    # TODO: Update to /W4
+    add_compile_options("/W3")
+    # Warn about nested declarations
+    add_compile_options("/w34456")
+    # Warn about potentially uninitialized variables
+    add_compile_options("/w34701")
+    add_compile_options("/w34703")
+    # Warn about different indirection types.
+    add_compile_options("/w34057")
+    # Warn about signed/unsigned mismatch.
+    add_compile_options("/w34245")
+endif()
+
+
+if (TOOLS_CODEGEN)
+    find_package(Python3 REQUIRED QUIET)
+    add_custom_target(tools_codegen
+        COMMAND Python3::Interpreter ${PROJECT_SOURCE_DIR}/scripts/generate_source.py
+            "${VULKAN_HEADERS_INSTALL_DIR}/${CMAKE_INSTALL_DATADIR}/vulkan/registry"
+            --incremental --generated-version ${VulkanHeaders_VERSION} --api ${API_TYPE}
+    )
+endif()
+
+# Default to using the static CRT
+set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+
+# Find the Git branch & tag info for use in Mock ICD
+find_package (Git)
+if (GIT_FOUND AND EXISTS "${CMAKE_CURRENT_LIST_DIR}/.git/HEAD")
+    execute_process(
+        COMMAND ${GIT_EXECUTABLE} describe --tags --always
+        WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
+        OUTPUT_VARIABLE GIT_TAG_INFO)
+    string(REGEX REPLACE "\n$" "" GIT_TAG_INFO "${GIT_TAG_INFO}")
+
+    file(READ "${CMAKE_CURRENT_LIST_DIR}/.git/HEAD" GIT_HEAD_REF_INFO)
+    if (GIT_HEAD_REF_INFO)
+        string(REGEX MATCH "ref: refs/heads/(.*)" _ ${GIT_HEAD_REF_INFO})
+        if (CMAKE_MATCH_1)
+            set(GIT_BRANCH_NAME ${CMAKE_MATCH_1})
+        else()
+            set(GIT_BRANCH_NAME ${GIT_HEAD_REF_INFO})
+        endif()
+        string(REGEX REPLACE "\n$" "" GIT_BRANCH_NAME "${GIT_BRANCH_NAME}")
+    endif()
+endif()
+
+if(BUILD_CUBE)
+    add_subdirectory(cube)
+endif()
+
+if(BUILD_VULKANINFO)
+    add_subdirectory(vulkaninfo)
+endif()
+
+if(BUILD_ICD)
+    add_subdirectory(icd)
+endif()
+
+
+if(BUILD_TESTS)
+    enable_testing()
+    add_subdirectory(tests)
+endif()
diff --git a/tools/Vulkan-Tools/CODE_OF_CONDUCT.md b/tools/Vulkan-Tools/CODE_OF_CONDUCT.md
new file mode 100644
index 00000000..a11610bd
--- /dev/null
+++ b/tools/Vulkan-Tools/CODE_OF_CONDUCT.md
@@ -0,0 +1 @@
+A reminder that this issue tracker is managed by the Khronos Group. Interactions here should follow the Khronos Code of Conduct (https://www.khronos.org/developers/code-of-conduct), which prohibits aggressive or derogatory language. Please keep the discussion friendly and civil.
diff --git a/tools/Vulkan-Tools/CONTRIBUTING.md b/tools/Vulkan-Tools/CONTRIBUTING.md
new file mode 100644
index 00000000..26c4c9bb
--- /dev/null
+++ b/tools/Vulkan-Tools/CONTRIBUTING.md
@@ -0,0 +1,103 @@
+# How to Contribute to Vulkan Source Repositories
+
+## **The Repository**
+
+The source code for The Vulkan-Tools components is sponsored by Khronos and LunarG.
+* [Khronos Vulkan-Tools](https://github.com/KhronosGroup/Vulkan-Tools)
+
+
+Repository Issue labels:
+
+* _Bug_:          These issues refer to invalid or broken functionality and are the highest priority.
+* _Enhancement_:  These issues refer to ideas for extending or improving tools and utilities
+
+It is the maintainers goal for all issues to be assigned within one business day of their submission. If you choose
+to work on an issue that is assigned, simply coordinate with the current assignee.
+
+### **How to Submit Fixes**
+
+* **Ensure that the bug was not already reported or fixed** by searching on GitHub under Issues
+  and Pull Requests.
+* Use the existing GitHub forking and pull request process.
+  This will involve [forking the repository](https://help.github.com/articles/fork-a-repo/),
+  creating a branch with your commits, and then [submitting a pull request](https://help.github.com/articles/using-pull-requests/).
+* Please read and adhere to the style and process [guidelines ](#coding-conventions-and-formatting) enumerated below.
+* Please base your fixes on the main branch.  SDK branches are generally not updated except for critical fixes needed to repair an SDK release.
+* The resulting Pull Request will be assigned to a repository maintainer. It is the maintainer's responsibility to ensure the Pull Request
+  passes the Google/LunarG internal CI processes. Once the Pull Request has been approved and is passing internal CI, a repository maintainer
+  will merge the PR.
+
+
+#### **Coding Conventions and Formatting**
+* Use the **[Google style guide](https://google.github.io/styleguide/cppguide.html)** for source code with the following exceptions:
+    * The column limit is 132 (as opposed to the default value 80). The clang-format tool will handle this. See below.
+    * The indent is 4 spaces instead of the default 2 spaces. Again, the clang-format tool will handle this.
+    * If you can justify a reason for violating a rule in the guidelines, then you are free to do so. Be prepared to defend your
+decision during code review. This should be used responsibly. An example of a bad reason is "I don't like that rule." An example of
+a good reason is "This violates the style guide, but it improves type safety."
+
+* Run **clang-format** on your changes to maintain consistent formatting
+    * There are `.clang-format` files present in the repository to define clang-format settings
+      which are found and used automatically by clang-format.
+	* **clang-format** binaries are available from the LLVM orginization, here: [LLVM](https://clang.llvm.org/).
+    * A sample git workflow may look like:
+
+>        # Make changes to the source.
+>        $ git add -u .
+>        $ git clang-format --style=file
+>        # Check to see if clang-format made any changes and if they are OK.
+>        $ git add -u .
+>        $ git commit
+
+* **Commit Messages**
+    * Limit the subject line to 50 characters -- this allows the information to display correctly in git/Github logs
+    * Begin subject line with a one-word component description followed by a colon (e.g. loader, layers, tests, etc.)
+    * Separate subject from body with a blank line
+    * Wrap the body at 72 characters
+    * Capitalize the subject line
+    * Do not end the subject line with a period
+    * Use the body to explain what and why vs. how
+    * Use the imperative mode in the subject line. This just means to write it as a command (e.g. Fix the sprocket)
+
+Strive for commits that implement a single or related set of functionality, using as many commits as is necessary (more is better).
+That said, please ensure that the repository compiles and passes tests without error for each commit in your pull request.  Note
+that to be accepted into the repository, the pull request must [pass all tests](#testing your changes) on all supported platforms
+
+#### Generated Source Code
+
+The `icd/generated` and `vulkaninfo/generated` directories contains source code that is created by several
+generator scripts in the `scripts` directory. All changes to these scripts _must_ be submitted with the
+corresponding generated output to keep the repository self-consistent. This requirement is enforced by CI.
+Regenerate source files after modifying any of the generator scripts and before building and testing your changes.
+More details can be found in [BUILD.md](BUILD.md).
+
+#### **Testing Your Changes**
+* Run the repository components with the Vulkan Validation Layers before and after each of your commits to check for any regressions.
+
+  (These instructions are for Linux)
+* In the `cube` directory, run:
+>        vkcube
+>        vkcube --validate
+* In the `vulkaninfo` directory, run:
+>        vulkaninfo
+* If you are adding or changing JSON output, please read
+  [Validating vulkaninfo JSON output](https://github.com/KhronosGroup/Vulkan-Tools/blob/main/vulkaninfo/json_validation_process.md).
+  **Note:** When adding new output to vulkaninfo, do NOT add JSON output unless the formmatting is defined by a schema.
+* Run tests that explicitly exercise your changes.
+* Feel free to subject your code changes to other tests as well!
+
+### **Contributor License Agreement (CLA)**
+
+You will be prompted with a one-time "click-through" CLA dialog as part of submitting your pull request
+or other contribution to GitHub.
+
+### **License and Copyrights**
+
+All contributions made to the Vulkan-Tools repository are Khronos branded and as such,
+any new files need to have the Khronos license (Apache 2.0 style) and copyright included.
+Please see an existing file in this repository for an example.
+
+All contributions made to the LunarG repositories are to be made under the Apache 2.0 license
+and any new files need to include this license and any applicable copyrights.
+
+You can include your individual copyright after any existing copyrights.
diff --git a/tools/Vulkan-Tools/GOVERNANCE.md b/tools/Vulkan-Tools/GOVERNANCE.md
new file mode 100644
index 00000000..7dd2c11c
--- /dev/null
+++ b/tools/Vulkan-Tools/GOVERNANCE.md
@@ -0,0 +1,51 @@
+## Khronos Group Vulkan-Tools Repository Management
+
+# **Open Source Project - Objectives**
+
+* Assist Vulkan Users
+  - The goal is for tool and utility behavior to assist in the development of vulkan applications.
+    - [Core Specification](https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html)
+    - [Header Files](https://www.khronos.org/registry/vulkan/#headers)
+    - [SDK Resources](https://vulkan.lunarg.com)
+* ISV Enablement
+  - Updates of tools and utilities should be available in a timely fashion
+  - Every effort will be made to be responsive to ISV issues
+* Cross Platform Compatibility
+  - Google and LunarG collaboration:
+    - Google: Monitor for Android
+    - LunarG: Monitor for desktop (Windows, Linux, and MacOS)
+    - Continuous Integration: HW test farms operated by Google and LunarG monitor various hardware/software platforms
+* Repo Quality
+  - Repo remains in healthy state with all tests passing and good-quality, consistent codebase
+  - Continuous Integration: Along with Github, HW test farms operated by Google and LunarG perform pre-commit cloud testing
+on pull-requests
+
+# **Roles and Definitions**
+* Contributor, Commenter, User
+  - Submitting contributions, creating issues, or using the contents of the repository
+* Approver
+  - Experienced project members who have made significant technical contributions
+  - Write control: Approve pull/merge requests (verify submissions vs. acceptance criteria)
+* Technical Project Leads
+  - Lead the project in terms of versioning, quality assurance, and overarching objectives
+  - Monitor github issues and drive timely resolution
+  - Designate new approvers
+  - Ensure project information such as the Readme, Contributing docs, wiki, etc., kept up-to-date
+  - Act as a facilitator in resolving technical conflicts
+  - Is a point-of-contact for project-related questions
+
+The technical project leads for this repository are:
+* **Jeremy Kniager** [jeremyk@lunarg.com](mailto:jeremyk@lunarg.com)
+
+# **Acceptance Criteria and Process**
+  - All source code to include Khronos copyright and license (Apache 2.0).
+    - Additional copyrights of contributors appended
+  - Contributions are via pull requests
+    - Project leads will assigning approvers to contributor pull requests
+    - Approvers can self-assign their reviewers
+    - For complex or invasive contributions, Project Leads may request approval from specific reviewers
+    - At least one review approval is required to complete a pull request
+    - The goal is to be responsive to contributors while ensuring acceptance criteria is met and to facilitate their submissions
+    - Approval is dependent upon adherence to the guidelines in [CONTRIBUTING.md](CONTRIBUTING.md), and alignment with
+repository goals of maintainability, completeness, and quality
+    - Conflicts or questions will ultimately be resolved by the project leads
diff --git a/tools/Vulkan-Tools/LICENSE.txt b/tools/Vulkan-Tools/LICENSE.txt
new file mode 100644
index 00000000..d6456956
--- /dev/null
+++ b/tools/Vulkan-Tools/LICENSE.txt
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/tools/Vulkan-Tools/README.md b/tools/Vulkan-Tools/README.md
new file mode 100644
index 00000000..0196b88c
--- /dev/null
+++ b/tools/Vulkan-Tools/README.md
@@ -0,0 +1,43 @@
+# KhronosGroup/Vulkan-Tools
+
+This project provides Vulkan tools and utilities that can assist development by enabling developers to verify their applications correct use of the Vulkan API.
+
+## Intro
+
+The following components are available in this repository:
+
+- [*Mock ICD*](icd/)
+- [*Vkcube and Vkcube++ Demo*](cube/)
+- [*VulkanInfo*](vulkaninfo/)
+- [*Windows Runtime*](windows-runtime-installer/)
+
+## Contact Information
+* [Charles Giessen](mailto:charles@lunarg.com)
+
+## Information for Developing or Contributing:
+
+Please see the [CONTRIBUTING.md](CONTRIBUTING.md) file in this repository for more details.
+Please see the [GOVERNANCE.md](GOVERNANCE.md) file in this repository for repository management details.
+
+## How to Build and Run
+
+[BUILD.md](BUILD.md) includes directions for building all components as well as running the vkcube demo applications.
+
+## Version Tagging Scheme
+
+Updates to this repository which correspond to a new Vulkan specification release are tagged using the following format: `v<`_`version`_`>` (e.g., `v1.3.266`).
+
+**Note**: Marked version releases have undergone thorough testing but do not imply the same quality level as SDK tags. SDK tags follow the `vulkan-sdk-<`_`version`_`>.<`_`patch`_`>` format (e.g., `vulkan-sdk-1.3.266.0`).
+
+This scheme was adopted following the `1.3.266` Vulkan specification release.
+
+## License
+This work is released as open source under a Apache-style license from Khronos including a Khronos copyright.
+
+See LICENSE.txt for a full list of licenses used in this repository.
+
+## Acknowledgements
+While this project has been developed primarily by LunarG, Inc., there are many other
+companies and individuals making this possible: Valve Corporation, funding
+project development; Google providing significant contributions to the validation layers;
+Khronos providing oversight and hosting of the project.
diff --git a/tools/Vulkan-Tools/cube/BUILD.gn b/tools/Vulkan-Tools/cube/BUILD.gn
new file mode 100644
index 00000000..502e3a50
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/BUILD.gn
@@ -0,0 +1,185 @@
+# Copyright (C) 2025 The Fuchsia Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+assert(is_fuchsia, "This build file works on Fuchsia GN build only.")
+
+import("//build/compiled_action.gni")
+import("//build/components.gni")
+import("//build_overrides/vulkan_tools.gni")
+import("//src/lib/vulkan/layers.gni")
+
+group("cube") {
+  testonly = true
+  deps = [
+    ":vkcube-on-fb",
+    ":vkcube-on-fb-protected",
+    ":vkcube-on-scenic",
+  ]
+}
+
+fuchsia_test_component("vkcube-on-fb-component") {
+  component_name = "vkcube-on-fb"
+  deps = [
+    ":vkcube",
+    "//src/lib/vulkan/swapchain:image_pipe_swapchain_fb_layer",
+    "//src/lib/vulkan/validation_layers",
+  ]
+  manifest = "fuchsia/meta/vkcube-on-fb.cml"
+  test_type = "system"
+}
+
+fuchsia_test_package("vkcube-on-fb") {
+  test_components = [ ":vkcube-on-fb-component" ]
+  test_specs = {
+    # vkcube runs forever, so only run manually.
+    environments = []
+  }
+}
+
+fuchsia_test_component("vkcube-on-fb-protected-component") {
+  deps = [
+    ":vkcube",
+    "//src/lib/vulkan/swapchain:image_pipe_swapchain_fb_layer",
+    "//src/lib/vulkan/validation_layers",
+  ]
+
+  manifest = "fuchsia/meta/vkcube-on-fb-protected.cml"
+  test_type = "system"
+}
+
+fuchsia_test_package("vkcube-on-fb-protected") {
+  test_components = [ ":vkcube-on-fb-protected-component" ]
+  test_specs = {
+    # vkcube runs forever, so only run manually.
+    environments = []
+  }
+}
+
+fuchsia_component("vkcube-on-scenic-component") {
+  component_name = "vkcube-on-scenic"
+  deps = [
+    ":vkcube",
+    "//src/lib/vulkan/swapchain:image_pipe_swapchain_layer",
+    "//src/lib/vulkan/validation_layers",
+  ]
+
+  manifest = "fuchsia/meta/vkcube-on-scenic.cml"
+}
+
+fuchsia_component("vkcube-on-scenic-protected-component") {
+  component_name = "vkcube-on-scenic-protected"
+  deps = [
+    ":vkcube",
+    "//src/lib/vulkan/swapchain:image_pipe_swapchain_layer",
+    "//src/lib/vulkan/validation_layers",
+  ]
+
+  manifest = "fuchsia/meta/vkcube-on-scenic-protected.cml"
+}
+
+fuchsia_package("vkcube-on-scenic") {
+  deps = [
+    ":vkcube-on-scenic-component",
+    ":vkcube-on-scenic-protected-component",
+  ]
+}
+
+config("cube_config") {
+  cube_frag_inc = "$target_gen_dir/cube.frag.inc"
+  cube_vert_inc = "$target_gen_dir/cube.vert.inc"
+
+  cube_frag_inc_rebased = rebase_path(cube_frag_inc, root_build_dir)
+  cube_vert_inc_rebased = rebase_path(cube_vert_inc, root_build_dir)
+
+  inputs = [
+    cube_frag_inc,
+    cube_vert_inc,
+  ]
+
+  defines = [
+    "CUBE_FRAG_INC=\"$cube_frag_inc_rebased\"",
+    "CUBE_VERT_INC=\"$cube_vert_inc_rebased\"",
+    "VULKAN_HPP_NO_NODISCARD_WARNINGS",
+  ]
+
+  include_dirs = [ root_build_dir ]
+
+  cflags = [ "-Wno-implicit-int-float-conversion" ]
+}
+
+executable("vkcube") {
+  defines = []
+  if (defined(texture_ppm_h)) {
+    path = rebase_path(texture_ppm_h, root_build_dir)
+    defines += [ "TEXTURE_PPM_H=\"$path\"" ]
+  }
+
+  sources = [
+    "cube.cpp",
+    "fuchsia/flatland_view.cpp",
+    "fuchsia/flatland_view.h",
+  ]
+
+  configs += [
+    ":cube_config",
+  ]
+
+  deps = [
+    ":glslang_frag",
+    ":glslang_vert",
+    "//sdk/fidl/fuchsia.ui.app:fuchsia.ui.app_cpp",
+    "//sdk/fidl/fuchsia.ui.composition:fuchsia.ui.composition_cpp",
+    "//sdk/fidl/fuchsia.ui.views:fuchsia.ui.views_cpp",
+    "//sdk/lib/async-loop:async-loop-cpp",
+    "//sdk/lib/component/incoming/cpp",
+    "//sdk/lib/component/outgoing/cpp",
+    "//sdk/lib/syslog/cpp",
+    "//sdk/lib/ui/scenic/cpp",
+    "//third_party/Vulkan-Headers/src:vulkan_headers",
+    "//third_party/Vulkan-Loader:libvulkan",
+    "//zircon/system/ulib/syslog",
+  ]
+}
+
+compiled_action("glslang_frag") {
+  tool = "//third_party/glslang:glslang_validator"
+  outputs = [ "$target_gen_dir/cube.frag.inc" ]
+
+  sources = [ "cube.frag" ]
+
+  args = [
+    "--quiet",
+    "-V",
+    "-x",
+    "-o",
+    rebase_path("$target_gen_dir/cube.frag.inc", root_build_dir),
+    rebase_path("cube.frag", root_build_dir),
+  ]
+}
+
+compiled_action("glslang_vert") {
+  tool = "//third_party/glslang:glslang_validator"
+  outputs = [ "$target_gen_dir/cube.vert.inc" ]
+
+  sources = [ "cube.vert" ]
+
+  args = [
+    "--quiet",
+    "-V",
+    "-x",
+    "-o",
+    rebase_path("$target_gen_dir/cube.vert.inc", root_build_dir),
+    rebase_path("cube.vert", root_build_dir),
+  ]
+}
diff --git a/tools/Vulkan-Tools/cube/CMakeLists.txt b/tools/Vulkan-Tools/cube/CMakeLists.txt
new file mode 100644
index 00000000..7c9b778a
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/CMakeLists.txt
@@ -0,0 +1,371 @@
+# ~~~
+# Copyright (c) 2018 Valve Corporation
+# Copyright (c) 2018 LunarG, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ~~~
+
+if(APPLE)
+    option(APPLE_USE_SYSTEM_ICD "Use system Vulkan ICD discovery instead of bundling MoltenVK" OFF)
+
+    if(APPLE_USE_SYSTEM_ICD)
+        message(STATUS "Using system Vulkan loader for ICD discovery")
+    else()
+        set(MOLTENVK_REPO_ROOT "MOLTENVK-NOTFOUND" CACHE PATH "Absolute path to a MoltenVK repo directory")
+        if(NOT MOLTENVK_REPO_ROOT)
+            message(FATAL_ERROR "Must define location of MoltenVK repo -- see BUILD.md")
+        endif()
+        message(STATUS "Using MoltenVK repo location at ${MOLTENVK_REPO_ROOT}")
+
+        # Source for the MoltenVK ICD library and JSON file
+        set(MOLTENVK_DIR ${MOLTENVK_REPO_ROOT})
+
+        # MoltenVK JSON File
+        execute_process(COMMAND mkdir -p ${PROJECT_BINARY_DIR}/staging-json)
+        execute_process(COMMAND sed -e "/\"library_path\":/s$:[[:space:]]*\"[[:space:]]*[\\.\\/]*$: \"..\\/..\\/..\\/Frameworks\\/$"
+                                ${MOLTENVK_DIR}/MoltenVK/icd/MoltenVK_icd.json
+                        OUTPUT_FILE ${PROJECT_BINARY_DIR}/staging-json/MoltenVK_icd.json)
+
+        # ~~~
+        # Modify the ICD JSON file to adjust the library path.
+        # The ICD JSON file goes in the Resources/vulkan/icd.d directory, so adjust the
+        # library_path to the relative path to the Frameworks directory in the bundle.
+        # The regex does: substitute ':<whitespace>"<whitespace><all occurences of . and />' with:
+        # ': "../../../Frameworks/'
+        # ~~~
+        add_custom_target(MoltenVK_icd-staging-json ALL
+            COMMAND mkdir -p ${PROJECT_BINARY_DIR}/staging-json
+            COMMAND sed -e "/\"library_path\":/s$:[[:space:]]*\"[[:space:]]*[\\.\\/]*$: \"..\\/..\\/..\\/Frameworks\\/$"
+                    ${MOLTENVK_DIR}/MoltenVK/icd/MoltenVK_icd.json > ${PROJECT_BINARY_DIR}/staging-json/MoltenVK_icd.json
+            VERBATIM
+            DEPENDS "${MOLTENVK_DIR}/MoltenVK/icd/MoltenVK_icd.json"
+        )
+        set_source_files_properties(${PROJECT_BINARY_DIR}/staging-json/MoltenVK_icd.json PROPERTIES GENERATED TRUE)
+    endif()
+
+    find_library(COCOA NAMES Cocoa)
+
+    # Locate Interface Builder Tool, needed to build things like Storyboards outside of Xcode.
+    if(NOT XCODE)
+        # Make sure we can find the 'ibtool' program. If we can NOT find it we skip generation of this project.
+        find_program(IBTOOL ibtool HINTS "/usr/bin" "${OSX_DEVELOPER_ROOT}/usr/bin")
+        if(${IBTOOL} STREQUAL "IBTOOL-NOTFOUND")
+            message(SEND_ERROR "ibtool can not be found and is needed to compile the .xib files. "
+                            "It should have been installed with the Apple developer tools. "
+                            "The default system paths were searched in addition to ${OSX_DEVELOPER_ROOT}/usr/bin.")
+        endif()
+    endif()
+endif()
+
+if(ANDROID OR APPLE)
+    set(WSI_DISPLAY_DEFAULT_SETTING "OFF")
+else()
+    set(WSI_DISPLAY_DEFAULT_SETTING "ON")
+endif()
+
+option(BUILD_WSI_DISPLAY_SUPPORT "Build DISPLAY WSI support" ${WSI_DISPLAY_DEFAULT_SETTING})
+
+if (CMAKE_SYSTEM_NAME MATCHES "Linux|BSD|GNU")
+    option(BUILD_WSI_XCB_SUPPORT "Build XCB WSI support" ON)
+    option(BUILD_WSI_XLIB_SUPPORT "Build Xlib WSI support" ON)
+    option(BUILD_WSI_WAYLAND_SUPPORT "Build Wayland WSI support" ON)
+    option(BUILD_WSI_DIRECTFB_SUPPORT "Build DirectFB WSI support" OFF)
+
+    find_package(PkgConfig REQUIRED QUIET) # Use PkgConfig to find Linux system libraries
+
+    if(BUILD_WSI_XCB_SUPPORT)
+        pkg_check_modules(XCB REQUIRED QUIET IMPORTED_TARGET xcb)
+        pkg_get_variable(XCB_INCLUDE_DIRS xcb includedir)
+        message(DEBUG "XCB_INCLUDE_DIRS = ${XCB_INCLUDE_DIRS}")
+    endif()
+
+    if(BUILD_WSI_XLIB_SUPPORT)
+        pkg_check_modules(X11 REQUIRED QUIET IMPORTED_TARGET x11)
+        pkg_get_variable(XLIB_INCLUDE_DIRS x11 includedir)
+        message(DEBUG "XLIB_INCLUDE_DIRS = ${XLIB_INCLUDE_DIRS}")
+    endif()
+
+    if(BUILD_WSI_WAYLAND_SUPPORT)
+        pkg_check_modules(WAYLAND_CLIENT REQUIRED IMPORTED_TARGET wayland-client)
+        pkg_get_variable(WAYLAND_INCLUDE_DIRS wayland-client includedir)
+
+        pkg_check_modules(WAYLAND_SCANNER REQUIRED wayland-scanner)
+        pkg_get_variable(WAYLAND_SCANNER_EXECUTABLE wayland-scanner wayland_scanner)
+        message(DEBUG "WAYLAND_SCANNER_EXECUTABLE = ${WAYLAND_SCANNER_EXECUTABLE}")
+
+        pkg_get_variable(WAYLAND_CLIENT_PATH wayland-client pkgdatadir)
+        message(DEBUG "WAYLAND_CLIENT_PATH = ${WAYLAND_CLIENT_PATH}")
+        set(WAYLAND_CODE_PROTOCOL ${WAYLAND_CLIENT_PATH}/wayland.xml)
+
+        pkg_check_modules(WAYLAND_PROTOCOLS REQUIRED wayland-protocols)
+        pkg_get_variable(WAYLAND_PROTOCOLS_PATH wayland-protocols pkgdatadir)
+        message(DEBUG "WAYLAND_PROTOCOLS_PATH = ${WAYLAND_PROTOCOLS_PATH}")
+        set(XDG_SHELL_PROTOCOL ${WAYLAND_PROTOCOLS_PATH}/stable/xdg-shell/xdg-shell.xml)
+
+        add_custom_command(COMMENT "Generating wayland client protocol dispatch data"
+                          OUTPUT wayland-client.c
+                          COMMAND ${WAYLAND_SCANNER_EXECUTABLE}
+                                  private-code
+                                  ${WAYLAND_CODE_PROTOCOL}
+                                  ${CMAKE_CURRENT_BINARY_DIR}/wayland-client.c
+                          MAIN_DEPENDENCY ${WAYLAND_CODE_PROTOCOL}
+                          DEPENDS ${WAYLAND_CODE_PROTOCOL} ${WAYLAND_SCANNER_EXECUTABLE})
+
+        add_custom_command(COMMENT "Generating xdg-shell protocol dispatch data"
+                           OUTPUT xdg-shell-code.c
+                           COMMAND ${WAYLAND_SCANNER_EXECUTABLE}
+                                   private-code
+                                   ${XDG_SHELL_PROTOCOL}
+                                   ${CMAKE_CURRENT_BINARY_DIR}/xdg-shell-code.c
+                           MAIN_DEPENDENCY ${XDG_SHELL_PROTOCOL}
+                           DEPENDS ${XDG_SHELL_PROTOCOL} ${WAYLAND_SCANNER_EXECUTABLE})
+        add_custom_command(COMMENT "Generating xdg-shell protocol header"
+                           OUTPUT xdg-shell-client-header.h
+                           COMMAND ${WAYLAND_SCANNER_EXECUTABLE}
+                                   client-header
+                                   ${XDG_SHELL_PROTOCOL}
+                                   ${CMAKE_CURRENT_BINARY_DIR}/xdg-shell-client-header.h
+                           MAIN_DEPENDENCY ${XDG_SHELL_PROTOCOL}
+                           DEPENDS ${XDG_SHELL_PROTOCOL} ${WAYLAND_SCANNER_EXECUTABLE})
+
+        set(XDG_DECORATION_PROTOCOL ${WAYLAND_PROTOCOLS_PATH}/unstable/xdg-decoration/xdg-decoration-unstable-v1.xml)
+        add_custom_command(COMMENT "Generating xdg-decoration protocol dispatch data"
+                           OUTPUT xdg-decoration-code.c
+                           COMMAND ${WAYLAND_SCANNER_EXECUTABLE}
+                                   private-code
+                                   ${XDG_DECORATION_PROTOCOL}
+                                   ${CMAKE_CURRENT_BINARY_DIR}/xdg-decoration-code.c
+                           MAIN_DEPENDENCY ${XDG_DECORATION_PROTOCOL}
+                           DEPENDS ${XDG_DECORATION_PROTOCOL} ${WAYLAND_SCANNER_EXECUTABLE})
+        add_custom_command(COMMENT "Generating xdg-decoration protocol header"
+                           OUTPUT xdg-decoration-client-header.h
+                           COMMAND ${WAYLAND_SCANNER_EXECUTABLE}
+                                   client-header
+                                   ${XDG_DECORATION_PROTOCOL}
+                                   ${CMAKE_CURRENT_BINARY_DIR}/xdg-decoration-client-header.h
+                           MAIN_DEPENDENCY ${XDG_DECORATION_PROTOCOL}
+                           DEPENDS ${XDG_DECORATION_PROTOCOL} ${WAYLAND_SCANNER_EXECUTABLE})
+
+        set(WAYLAND_ADDITIONAL_SOURCES ${CMAKE_CURRENT_BINARY_DIR}/wayland-client.c
+                           ${CMAKE_CURRENT_BINARY_DIR}/xdg-shell-code.c
+                           ${CMAKE_CURRENT_BINARY_DIR}/xdg-shell-client-header.h
+                           ${CMAKE_CURRENT_BINARY_DIR}/xdg-decoration-code.c
+                           ${CMAKE_CURRENT_BINARY_DIR}/xdg-decoration-client-header.h)
+    endif()
+
+    if(BUILD_WSI_DIRECTFB_SUPPORT)
+        pkg_check_modules(DirectFB REQUIRED QUIET IMPORTED_TARGET directfb)
+    endif()
+endif()
+
+if(BUILD_WSI_DISPLAY_SUPPORT)
+    list(APPEND ENABLED_CUBE_PLATFORMS VK_USE_PLATFORM_DISPLAY_KHR)
+endif()
+
+if(WIN32)
+    add_definitions(-DWIN32_LEAN_AND_MEAN -DNOMINMAX)
+    list(APPEND ENABLED_CUBE_PLATFORMS VK_USE_PLATFORM_WIN32_KHR)
+elseif(ANDROID)
+    list(APPEND ENABLED_CUBE_PLATFORMS VK_USE_PLATFORM_ANDROID_KHR)
+elseif(APPLE)
+    list(APPEND ENABLED_CUBE_PLATFORMS VK_USE_PLATFORM_METAL_EXT)
+elseif(CMAKE_SYSTEM_NAME MATCHES "Linux|BSD|GNU")
+    if(BUILD_WSI_XCB_SUPPORT)
+        list(APPEND ENABLED_CUBE_PLATFORMS VK_USE_PLATFORM_XCB_KHR)
+    endif()
+    if(BUILD_WSI_XLIB_SUPPORT)
+        list(APPEND ENABLED_CUBE_PLATFORMS VK_USE_PLATFORM_XLIB_KHR)
+    endif()
+    if(BUILD_WSI_WAYLAND_SUPPORT)
+        list(APPEND ENABLED_CUBE_PLATFORMS VK_USE_PLATFORM_WAYLAND_KHR)
+    endif()
+    if(BUILD_WSI_DIRECTFB_SUPPORT)
+        list(APPEND ENABLED_CUBE_PLATFORMS VK_USE_PLATFORM_DIRECTFB_EXT)
+    endif()
+    link_libraries(${API_LOWERCASE} m)
+else()
+    message(FATAL_ERROR "Unsupported Platform!")
+endif()
+
+if(NOT DEFINED ENABLED_CUBE_PLATFORMS)
+        message(FATAL_ERROR "There are no supported WSI platforms on this system, vkcube requires a WSI platform be available to be able to render its output")
+endif()
+
+if (COMPILE_CUBE_SHADERS)
+    # Try to find glslang in system paths or in an SDK if the VULKAN_SDK env-var is set
+    find_program(GLSLANG_VALIDATOR names glslang glslangValidator HINTS $ENV{GLSLANG_INSTALL_DIR} $ENV{VULKAN_SDK}/bin $ENV{VULKAN_SDK}/Bin)
+
+    add_custom_command(COMMENT "Compiling cube vertex shader"
+                    OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/cube.vert.inc
+                    COMMAND ${GLSLANG_VALIDATOR} -V -x -o ${CMAKE_CURRENT_SOURCE_DIR}/cube.vert.inc
+                            ${PROJECT_SOURCE_DIR}/cube/cube.vert
+                    MAIN_DEPENDENCY ${PROJECT_SOURCE_DIR}/cube/cube.vert
+                    DEPENDS ${PROJECT_SOURCE_DIR}/cube/cube.vert ${GLSLANG_VALIDATOR})
+    add_custom_command(COMMENT "Compiling cube fragment shader"
+                    OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/cube.frag.inc
+                    COMMAND ${GLSLANG_VALIDATOR} -V -x -o ${CMAKE_CURRENT_SOURCE_DIR}/cube.frag.inc
+                            ${PROJECT_SOURCE_DIR}/cube/cube.frag
+                    MAIN_DEPENDENCY ${PROJECT_SOURCE_DIR}/cube/cube.frag
+                    DEPENDS ${PROJECT_SOURCE_DIR}/cube/cube.frag ${GLSLANG_VALIDATOR})
+endif()
+
+if(WIN32)
+    add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
+    # vkcube / vkcube make use of M_PI and various other math defines.
+    add_compile_definitions(_USE_MATH_DEFINES)
+endif()
+
+
+# On Ubuntu 20.04, it was found that the validation layers fail to launch in vkcube & vkcubepp due to
+# a missing dependency on libpthread. While newer Ubuntu versions use a glibc version where libpthread
+# is integrated into libc, older ubuntu's do not so we need to link threads directly in order for
+# validation layers to be loadable.
+if (CMAKE_SYSTEM_NAME MATCHES "Linux|BSD|GNU")
+    find_package(Threads REQUIRED)
+endif()
+
+# ----------------------------------------------------------------------------
+# vkcube
+
+if(APPLE)
+    add_subdirectory(macOS/cube)
+elseif (ANDROID)
+    add_library(vkcube MODULE)
+
+    target_sources(vkcube PRIVATE cube.c)
+
+    add_subdirectory(android)
+
+elseif(CMAKE_SYSTEM_NAME MATCHES "Linux|BSD|GNU")
+    add_executable(vkcube)
+    target_sources(vkcube PRIVATE
+        cube.c
+        ${PROJECT_SOURCE_DIR}/cube/cube.vert
+        ${PROJECT_SOURCE_DIR}/cube/cube.frag
+        cube.vert.inc
+        cube.frag.inc
+    )
+    target_link_libraries(vkcube  Threads::Threads)
+    if(BUILD_WSI_XCB_SUPPORT)
+        target_sources(vkcube PRIVATE xcb_loader.h)
+        target_include_directories(vkcube PRIVATE ${xcb_INCLUDE_DIRS})
+    endif()
+    if(BUILD_WSI_XLIB_SUPPORT)
+        target_sources(vkcube PRIVATE xlib_loader.h)
+        target_include_directories(vkcube PRIVATE ${XLIB_INCLUDE_DIRS})
+    endif()
+    if(BUILD_WSI_WAYLAND_SUPPORT)
+        target_include_directories(vkcube PRIVATE ${WAYLAND_INCLUDE_DIRS} ${CMAKE_CURRENT_BINARY_DIR})
+        target_sources(vkcube PRIVATE PRIVATE ${WAYLAND_ADDITIONAL_SOURCES})
+    endif()
+    if(BUILD_WSI_DIRECTFB_SUPPORT)
+        target_link_libraries(vkcube PkgConfig::DirectFB)
+    endif()
+    include(CheckLibraryExists)
+    CHECK_LIBRARY_EXISTS("rt" clock_gettime "" NEED_RT)
+    if (NEED_RT)
+        target_link_libraries(vkcube  rt)
+    endif()
+elseif(WIN32)
+    add_executable(vkcube WIN32)
+    target_sources(vkcube PRIVATE
+        cube.c
+        ${PROJECT_SOURCE_DIR}/cube/cube.vert
+        ${PROJECT_SOURCE_DIR}/cube/cube.frag
+        cube.vert.inc
+        cube.frag.inc
+    )
+else()
+    message(FATAL_ERROR "Unsupported Platform!")
+endif()
+
+target_compile_definitions(vkcube PRIVATE ${ENABLED_CUBE_PLATFORMS})
+target_include_directories(vkcube PRIVATE .)
+target_link_libraries(vkcube ${CMAKE_DL_LIBS} Vulkan::Headers)
+
+if (ANDROID)
+    install(TARGETS vkcube DESTINATION ${CMAKE_INSTALL_LIBDIR})
+elseif(APPLE)
+    install(
+        TARGETS vkcube
+        # Install runtime dependencies like the Vulkan::Loader so the app is self-contained
+        RUNTIME_DEPENDENCIES DESTINATION "cube/vkcube.app/Contents/Frameworks/"
+        BUNDLE DESTINATION "cube"
+    )
+    set_target_properties(vkcube PROPERTIES
+        INSTALL_RPATH @executable_path/../Frameworks
+    )
+else()
+    install(TARGETS vkcube)
+endif()
+
+if (ANDROID)
+    return()
+endif()
+
+# ----------------------------------------------------------------------------
+# vkcubepp
+
+if(APPLE)
+    add_subdirectory(macOS/cubepp)
+elseif(CMAKE_SYSTEM_NAME MATCHES "Linux|BSD|GNU")
+    add_executable(vkcubepp
+                   cube.cpp
+                   ${PROJECT_SOURCE_DIR}/cube/cube.vert
+                   ${PROJECT_SOURCE_DIR}/cube/cube.frag
+                   cube.vert.inc
+                   cube.frag.inc)
+    target_link_libraries(vkcubepp  Threads::Threads)
+
+    if(BUILD_WSI_XCB_SUPPORT)
+        target_sources(vkcubepp PRIVATE xcb_loader.h)
+        target_include_directories(vkcubepp PRIVATE ${xcb_INCLUDE_DIRS})
+    endif()
+    if(BUILD_WSI_XLIB_SUPPORT)
+        target_sources(vkcubepp PRIVATE xlib_loader.h)
+        target_include_directories(vkcubepp PRIVATE ${XLIB_INCLUDE_DIRS})
+    endif()
+    if(BUILD_WSI_WAYLAND_SUPPORT)
+        target_include_directories(vkcubepp PRIVATE ${WAYLAND_INCLUDE_DIRS} ${CMAKE_CURRENT_BINARY_DIR})
+        target_sources(vkcubepp PRIVATE ${WAYLAND_ADDITIONAL_SOURCES})
+    endif()
+    if(BUILD_WSI_DIRECTFB_SUPPORT)
+        target_link_libraries(vkcubepp  PkgConfig::DirectFB)
+    endif()
+else()
+    add_executable(vkcubepp
+                   WIN32
+                   cube.cpp
+                   ${PROJECT_SOURCE_DIR}/cube/cube.vert
+                   ${PROJECT_SOURCE_DIR}/cube/cube.frag
+                   cube.vert.inc
+                   cube.frag.inc)
+endif()
+
+target_include_directories(vkcubepp PRIVATE .)
+target_compile_definitions(vkcubepp PRIVATE ${ENABLED_CUBE_PLATFORMS})
+target_link_libraries(vkcubepp ${CMAKE_DL_LIBS} Vulkan::Headers)
+
+if(APPLE)
+    install(
+        TARGETS vkcubepp
+        # Install runtime dependencies like the Vulkan::Loader so the app is self-contained
+        RUNTIME_DEPENDENCIES DESTINATION "cube/vkcubepp.app/Contents/Frameworks/"
+        BUNDLE DESTINATION "cube"
+    )
+    set_target_properties(vkcubepp PROPERTIES
+        INSTALL_RPATH @executable_path/../Frameworks
+    )
+else()
+    install(TARGETS vkcubepp)
+endif()
diff --git a/tools/Vulkan-Tools/cube/android/AndroidManifest.xml b/tools/Vulkan-Tools/cube/android/AndroidManifest.xml
new file mode 100644
index 00000000..fbec106d
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/android/AndroidManifest.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example.VkCube" android:versionCode="1" android:versionName="1.0">
+
+    <!-- Allow this app to read and write files (for use by tracing libraries). -->
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
+    <uses-permission android:name="android.permission.INTERNET"/>
+
+    <uses-sdk android:minSdkVersion="23" android:targetSdkVersion="23"/>
+
+    <!-- This .apk has no Java code itself, so set hasCode to false. -->
+    <application android:label="VkCube" android:hasCode="false" android:debuggable='true'>
+
+        <!-- Our activity is the built-in NativeActivity framework class.
+             This will take care of integrating with our NDK code. -->
+        <activity android:name="android.app.NativeActivity" android:label="VkCube" android:exported="true">
+            <!-- Tell NativeActivity the name of or .so -->
+            <meta-data android:name="android.app.lib_name" android:value="VkCube"/>
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN"/>
+                <category android:name="android.intent.category.LAUNCHER"/>
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>
diff --git a/tools/Vulkan-Tools/cube/android/CMakeLists.txt b/tools/Vulkan-Tools/cube/android/CMakeLists.txt
new file mode 100644
index 00000000..af607a55
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/android/CMakeLists.txt
@@ -0,0 +1,57 @@
+# ~~~
+# Copyright (c) 2023 Valve Corporation
+# Copyright (c) 2023 LunarG, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ~~~
+
+target_sources(vkcube PRIVATE
+    android_util.cpp
+    android_util.h
+)
+
+target_include_directories(vkcube PRIVATE
+    .
+)
+
+set_directory_properties(PROPERTIES "COMPILE_OPTIONS" "") # Disable compiler warnings for android glue
+
+set(native_app_glue_dir "${CMAKE_ANDROID_NDK}/sources/android/native_app_glue")
+
+if (NOT EXISTS ${native_app_glue_dir})
+    message(FATAL_ERROR "Couldn't find Android Native Glue directory!")
+endif()
+
+# https://stackoverflow.com/questions/57189936/compiling-native-app-glue-c-results-in-an-invalid-library-file/76963564#76963564
+add_library(android_glue OBJECT)
+
+target_include_directories(android_glue PUBLIC ${native_app_glue_dir})
+target_sources(android_glue PRIVATE
+    ${native_app_glue_dir}/android_native_app_glue.c
+    ${native_app_glue_dir}/android_native_app_glue.h
+)
+
+set_target_properties(vkcube PROPERTIES OUTPUT_NAME "VkCube")
+
+target_link_libraries(vkcube
+    android_glue
+    log
+    android
+)
+
+# https://stackoverflow.com/questions/76631917/cmake-how-to-install-shared-stl-libraries-for-android/76656492#76656492
+if ("${CMAKE_ANDROID_STL_TYPE}" MATCHES "shared")
+    file(READ "${CMAKE_ANDROID_NDK}/meta/abis.json" JSON_FILE)
+    string(JSON TRIPLE GET "${JSON_FILE}" "${CMAKE_ANDROID_ARCH_ABI}" "triple")
+    install(FILES "${CMAKE_SYSROOT}/usr/lib/${TRIPLE}/libc++_shared.so" DESTINATION "${CMAKE_INSTALL_LIBDIR}")
+endif()
diff --git a/tools/Vulkan-Tools/cube/android/android_util.cpp b/tools/Vulkan-Tools/cube/android/android_util.cpp
new file mode 100644
index 00000000..173e8ab8
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/android/android_util.cpp
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2016 Google, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Relicensed from the WTFPL (http://www.wtfpl.net/faq/).
+ */
+
+#include "android_util.h"
+#include <android_native_app_glue.h>
+#include <cassert>
+#include <cstring>
+#include <vector>
+#include <string>
+#include <sstream>
+#include <stdlib.h>
+
+extern "C" {
+
+// Convert Intents to arg list, returning argc and argv
+// Note that this C routine mallocs memory that the caller must free
+char **get_args(struct android_app *app, const char *intent_extra_data_key, const char *appTag, int *count) {
+    std::vector<std::string> args;
+    JavaVM &vm = *app->activity->vm;
+    JNIEnv *p_env;
+    if (vm.AttachCurrentThread(&p_env, nullptr) != JNI_OK) return nullptr;
+
+    JNIEnv &env = *p_env;
+    jobject activity = app->activity->clazz;
+    jmethodID get_intent_method = env.GetMethodID(env.GetObjectClass(activity), "getIntent", "()Landroid/content/Intent;");
+    jobject intent = env.CallObjectMethod(activity, get_intent_method);
+    jmethodID get_string_extra_method =
+        env.GetMethodID(env.GetObjectClass(intent), "getStringExtra", "(Ljava/lang/String;)Ljava/lang/String;");
+    jvalue get_string_extra_args;
+    get_string_extra_args.l = env.NewStringUTF(intent_extra_data_key);
+    jstring extra_str = static_cast<jstring>(env.CallObjectMethodA(intent, get_string_extra_method, &get_string_extra_args));
+
+    std::string args_str;
+    if (extra_str) {
+        const char *extra_utf = env.GetStringUTFChars(extra_str, nullptr);
+        args_str = extra_utf;
+        env.ReleaseStringUTFChars(extra_str, extra_utf);
+        env.DeleteLocalRef(extra_str);
+    }
+
+    env.DeleteLocalRef(get_string_extra_args.l);
+    env.DeleteLocalRef(intent);
+    vm.DetachCurrentThread();
+
+    // split args_str
+    std::stringstream ss(args_str);
+    std::string arg;
+    while (std::getline(ss, arg, ' ')) {
+        if (!arg.empty()) args.push_back(arg);
+    }
+
+    // Convert our STL results to C friendly constructs
+    assert(count != nullptr);
+    *count = args.size() + 1;
+    char **vector = (char **)malloc(*count * sizeof(char *));
+    const char *appName = appTag ? appTag : (const char *)"appTag";
+
+    vector[0] = (char *)malloc(strlen(appName) * sizeof(char));
+    strcpy(vector[0], appName);
+
+    for (uint32_t i = 0; i < args.size(); i++) {
+        vector[i + 1] = (char *)malloc(strlen(args[i].c_str()) * sizeof(char));
+        strcpy(vector[i + 1], args[i].c_str());
+    }
+
+    return vector;
+}
+
+}  // extern "C"
diff --git a/tools/Vulkan-Tools/cube/android/android_util.h b/tools/Vulkan-Tools/cube/android/android_util.h
new file mode 100644
index 00000000..e8966458
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/android/android_util.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2016 Google, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Relicensed from the WTFPL (http://www.wtfpl.net/faq/).
+ */
+
+#ifndef ANDROID_UTIL_H
+#define ANDROID_UTIL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+char **get_args(struct android_app *app, const char *intent_extra_data_key, const char *appTag, int *count);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/tools/Vulkan-Tools/cube/cube.c b/tools/Vulkan-Tools/cube/cube.c
new file mode 100644
index 00000000..d28285de
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/cube.c
@@ -0,0 +1,5199 @@
+/*
+ * Copyright (c) 2015-2019 The Khronos Group Inc.
+ * Copyright (c) 2015-2019 Valve Corporation
+ * Copyright (c) 2015-2019 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Chia-I Wu <olv@lunarg.com>
+ * Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
+ * Author: Ian Elliott <ian@LunarG.com>
+ * Author: Ian Elliott <ianelliott@google.com>
+ * Author: Jon Ashburn <jon@lunarg.com>
+ * Author: Gwan-gyeong Mun <elongbug@gmail.com>
+ * Author: Tony Barbour <tony@LunarG.com>
+ * Author: Bill Hollings <bill.hollings@brenwill.com>
+ */
+
+#define _GNU_SOURCE
+#include <ctype.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <assert.h>
+#include <signal.h>
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+#include <errno.h>
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+#include "xlib_loader.h"
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+#include "xcb_loader.h"
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+#include <linux/input.h>
+#include "wayland_loader.h"
+#endif
+
+#ifdef _WIN32
+#ifdef _MSC_VER
+#pragma comment(linker, "/subsystem:windows")
+#endif  // MSVC
+#define APP_NAME_STR_LEN 80
+#endif  // _WIN32
+
+#include "cube_functions.h"
+
+#include <vulkan/vulkan.h>
+
+#include "linmath.h"
+#include "object_type_string_helper.h"
+
+#include "gettime.h"
+#include "inttypes.h"
+#define MILLION 1000000L
+#define BILLION 1000000000L
+
+#define DEMO_TEXTURE_COUNT 1
+#define APP_SHORT_NAME "vkcube"
+#define APP_LONG_NAME "Vulkan Cube"
+
+// Allow a maximum of two outstanding presentation operations.
+#define FRAME_LAG 2
+// Need to know how big of a buffer of swapchain images, image views, and semaphores are needed
+#define MAX_SWAPCHAIN_IMAGE_COUNT 8
+
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
+
+#if defined(NDEBUG) && defined(__GNUC__)
+#define U_ASSERT_ONLY __attribute__((unused))
+#else
+#define U_ASSERT_ONLY
+#endif
+
+#if defined(__GNUC__)
+#define UNUSED __attribute__((unused))
+#else
+#define UNUSED
+#endif
+
+#ifdef _WIN32
+bool in_callback = false;
+#define ERR_EXIT(err_msg, err_class)                                             \
+    do {                                                                         \
+        if (!demo->suppress_popups) MessageBox(NULL, err_msg, err_class, MB_OK); \
+        exit(1);                                                                 \
+    } while (0)
+void DbgMsg(char *fmt, ...) {
+    va_list va;
+    va_start(va, fmt);
+    vprintf(fmt, va);
+    va_end(va);
+    fflush(stdout);
+}
+
+#elif defined __ANDROID__
+#include <android/log.h>
+#define ERR_EXIT(err_msg, err_class)                                           \
+    do {                                                                       \
+        ((void)__android_log_print(ANDROID_LOG_INFO, "Vulkan Cube", err_msg)); \
+        exit(1);                                                               \
+    } while (0)
+#ifdef VARARGS_WORKS_ON_ANDROID
+void DbgMsg(const char *fmt, ...) {
+    va_list va;
+    va_start(va, fmt);
+    __android_log_print(ANDROID_LOG_INFO, "Vulkan Cube", fmt, va);
+    va_end(va);
+}
+#else  // VARARGS_WORKS_ON_ANDROID
+#define DbgMsg(fmt, ...)                                                                  \
+    do {                                                                                  \
+        ((void)__android_log_print(ANDROID_LOG_INFO, "Vulkan Cube", fmt, ##__VA_ARGS__)); \
+    } while (0)
+#endif  // VARARGS_WORKS_ON_ANDROID
+#else
+#define ERR_EXIT(err_msg, err_class) \
+    do {                             \
+        printf("%s\n", err_msg);     \
+        fflush(stdout);              \
+        exit(1);                     \
+    } while (0)
+void DbgMsg(char *fmt, ...) {
+    va_list va;
+    va_start(va, fmt);
+    vprintf(fmt, va);
+    va_end(va);
+    fflush(stdout);
+}
+#endif
+
+/*
+ * structure to track all objects related to a texture.
+ */
+struct texture_object {
+    VkSampler sampler;
+
+    VkImage image;
+    VkBuffer buffer;
+    VkImageLayout imageLayout;
+
+    VkMemoryAllocateInfo mem_alloc;
+    VkDeviceMemory mem;
+    VkImageView view;
+    int32_t tex_width, tex_height;
+};
+
+static char *tex_files[] = {"lunarg.ppm"};
+
+static int validation_error = 0;
+
+struct vktexcube_vs_uniform {
+    // Must start with MVP
+    float mvp[4][4];
+    float position[12 * 3][4];
+    float attr[12 * 3][4];
+};
+
+//--------------------------------------------------------------------------------------
+// Mesh and VertexFormat Data
+//--------------------------------------------------------------------------------------
+// clang-format off
+static const float g_vertex_buffer_data[] = {
+    -1.0f,-1.0f,-1.0f,  // -X side
+    -1.0f,-1.0f, 1.0f,
+    -1.0f, 1.0f, 1.0f,
+    -1.0f, 1.0f, 1.0f,
+    -1.0f, 1.0f,-1.0f,
+    -1.0f,-1.0f,-1.0f,
+
+    -1.0f,-1.0f,-1.0f,  // -Z side
+     1.0f, 1.0f,-1.0f,
+     1.0f,-1.0f,-1.0f,
+    -1.0f,-1.0f,-1.0f,
+    -1.0f, 1.0f,-1.0f,
+     1.0f, 1.0f,-1.0f,
+
+    -1.0f,-1.0f,-1.0f,  // -Y side
+     1.0f,-1.0f,-1.0f,
+     1.0f,-1.0f, 1.0f,
+    -1.0f,-1.0f,-1.0f,
+     1.0f,-1.0f, 1.0f,
+    -1.0f,-1.0f, 1.0f,
+
+    -1.0f, 1.0f,-1.0f,  // +Y side
+    -1.0f, 1.0f, 1.0f,
+     1.0f, 1.0f, 1.0f,
+    -1.0f, 1.0f,-1.0f,
+     1.0f, 1.0f, 1.0f,
+     1.0f, 1.0f,-1.0f,
+
+     1.0f, 1.0f,-1.0f,  // +X side
+     1.0f, 1.0f, 1.0f,
+     1.0f,-1.0f, 1.0f,
+     1.0f,-1.0f, 1.0f,
+     1.0f,-1.0f,-1.0f,
+     1.0f, 1.0f,-1.0f,
+
+    -1.0f, 1.0f, 1.0f,  // +Z side
+    -1.0f,-1.0f, 1.0f,
+     1.0f, 1.0f, 1.0f,
+    -1.0f,-1.0f, 1.0f,
+     1.0f,-1.0f, 1.0f,
+     1.0f, 1.0f, 1.0f,
+};
+
+static const float g_uv_buffer_data[] = {
+    0.0f, 1.0f,  // -X side
+    1.0f, 1.0f,
+    1.0f, 0.0f,
+    1.0f, 0.0f,
+    0.0f, 0.0f,
+    0.0f, 1.0f,
+
+    1.0f, 1.0f,  // -Z side
+    0.0f, 0.0f,
+    0.0f, 1.0f,
+    1.0f, 1.0f,
+    1.0f, 0.0f,
+    0.0f, 0.0f,
+
+    1.0f, 0.0f,  // -Y side
+    1.0f, 1.0f,
+    0.0f, 1.0f,
+    1.0f, 0.0f,
+    0.0f, 1.0f,
+    0.0f, 0.0f,
+
+    1.0f, 0.0f,  // +Y side
+    0.0f, 0.0f,
+    0.0f, 1.0f,
+    1.0f, 0.0f,
+    0.0f, 1.0f,
+    1.0f, 1.0f,
+
+    1.0f, 0.0f,  // +X side
+    0.0f, 0.0f,
+    0.0f, 1.0f,
+    0.0f, 1.0f,
+    1.0f, 1.0f,
+    1.0f, 0.0f,
+
+    0.0f, 0.0f,  // +Z side
+    0.0f, 1.0f,
+    1.0f, 0.0f,
+    0.0f, 1.0f,
+    1.0f, 1.0f,
+    1.0f, 0.0f,
+};
+// clang-format on
+
+void dumpMatrix(const char *note, mat4x4 MVP) {
+    int i;
+
+    printf("%s: \n", note);
+    for (i = 0; i < 4; i++) {
+        printf("%f, %f, %f, %f\n", MVP[i][0], MVP[i][1], MVP[i][2], MVP[i][3]);
+    }
+    printf("\n");
+    fflush(stdout);
+}
+
+void dumpVec4(const char *note, vec4 vector) {
+    printf("%s: \n", note);
+    printf("%f, %f, %f, %f\n", vector[0], vector[1], vector[2], vector[3]);
+    printf("\n");
+    fflush(stdout);
+}
+
+char const *to_string(VkPhysicalDeviceType const type) {
+    switch (type) {
+        case VK_PHYSICAL_DEVICE_TYPE_OTHER:
+            return "Other";
+        case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU:
+            return "IntegratedGpu";
+        case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:
+            return "DiscreteGpu";
+        case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU:
+            return "VirtualGpu";
+        case VK_PHYSICAL_DEVICE_TYPE_CPU:
+            return "Cpu";
+        default:
+            return "Unknown";
+    }
+}
+
+typedef enum WSI_PLATFORM {
+    WSI_PLATFORM_AUTO = 0,
+    WSI_PLATFORM_WIN32,
+    WSI_PLATFORM_METAL,
+    WSI_PLATFORM_ANDROID,
+    WSI_PLATFORM_QNX,
+    WSI_PLATFORM_XCB,
+    WSI_PLATFORM_XLIB,
+    WSI_PLATFORM_WAYLAND,
+    WSI_PLATFORM_DIRECTFB,
+    WSI_PLATFORM_DISPLAY,
+    WSI_PLATFORM_INVALID,  // Sentinel just to indicate invalid user input
+} WSI_PLATFORM;
+
+WSI_PLATFORM wsi_from_string(const char *str) {
+    if (strcmp(str, "auto") == 0) return WSI_PLATFORM_AUTO;
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+    if (strcmp(str, "win32") == 0) return WSI_PLATFORM_WIN32;
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+    if (strcmp(str, "metal") == 0) return WSI_PLATFORM_METAL;
+#endif
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+    if (strcmp(str, "android") == 0) return WSI_PLATFORM_ANDROID;
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+    if (strcmp(str, "qnx") == 0) return WSI_PLATFORM_QNX;
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+    if (strcmp(str, "xcb") == 0) return WSI_PLATFORM_XCB;
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+    if (strcmp(str, "xlib") == 0) return WSI_PLATFORM_XLIB;
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+    if (strcmp(str, "wayland") == 0) return WSI_PLATFORM_WAYLAND;
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+    if (strcmp(str, "directfb") == 0) return WSI_PLATFORM_DIRECTFB;
+#endif
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+    if (strcmp(str, "display") == 0) return WSI_PLATFORM_DISPLAY;
+#endif
+    return WSI_PLATFORM_INVALID;
+};
+
+const char *wsi_to_string(WSI_PLATFORM wsi_platform) {
+    switch (wsi_platform) {
+        case (WSI_PLATFORM_AUTO):
+            return "auto";
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+        case (WSI_PLATFORM_WIN32):
+            return "win32";
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+        case (WSI_PLATFORM_METAL):
+            return "metal";
+#endif
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+        case (WSI_PLATFORM_ANDROID):
+            return "android";
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+        case (WSI_PLATFORM_QNX):
+            return "qnx";
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+        case (WSI_PLATFORM_XCB):
+            return "xcb";
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+        case (WSI_PLATFORM_XLIB):
+            return "xlib";
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+        case (WSI_PLATFORM_WAYLAND):
+            return "wayland";
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+        case (WSI_PLATFORM_DIRECTFB):
+            return "directfb";
+#endif
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+        case (WSI_PLATFORM_DISPLAY):
+            return "display";
+#endif
+        default:
+            return "unknown";
+    }
+};
+
+typedef struct {
+    VkFence fence;
+    VkSemaphore image_acquired_semaphore;
+    VkCommandBuffer cmd;
+    VkCommandBuffer graphics_to_present_cmd;
+    VkBuffer uniform_buffer;
+    VkDeviceMemory uniform_memory;
+    void *uniform_memory_ptr;
+    VkDescriptorSet descriptor_set;
+} SubmissionResources;
+
+typedef struct {
+    VkImage image;
+    VkImageView view;
+    VkFramebuffer framebuffer;
+    VkSemaphore draw_complete_semaphore;
+    VkSemaphore image_ownership_semaphore;
+} SwapchainImageResources;
+
+struct demo {
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+#define APP_NAME_STR_LEN 80
+    HINSTANCE connection;         // hInstance - Windows Instance
+    char name[APP_NAME_STR_LEN];  // Name to put on the window/icon
+    HWND window;                  // hWnd - window handle
+    POINT minsize;                // minimum window size
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+    void *xlib_library;
+    Display *xlib_display;
+    Window xlib_window;
+    Atom xlib_wm_delete_window;
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+    void *xcb_library;
+    Display *xcb_display;
+    xcb_connection_t *connection;
+    xcb_screen_t *screen;
+    xcb_window_t xcb_window;
+    xcb_intern_atom_reply_t *atom_wm_delete_window;
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+    void *wayland_library;  // Dynamic library for wayland
+    struct wl_display *wayland_display;
+    struct wl_registry *registry;
+    struct wl_compositor *compositor;
+    struct wl_surface *window;
+    struct xdg_wm_base *xdg_wm_base;
+    struct zxdg_decoration_manager_v1 *xdg_decoration_mgr;
+    struct zxdg_toplevel_decoration_v1 *toplevel_decoration;
+    struct xdg_surface *xdg_surface;
+    int xdg_surface_has_been_configured;
+    struct xdg_toplevel *xdg_toplevel;
+    struct wl_seat *seat;
+    struct wl_pointer *pointer;
+    struct wl_keyboard *keyboard;
+    int pending_width, pending_height;
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+    IDirectFB *dfb;
+    IDirectFBSurface *directfb_window;
+    IDirectFBEventBuffer *event_buffer;
+#endif
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+    struct ANativeWindow *window;
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+    void *caMetalLayer;
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+    screen_context_t screen_context;
+    screen_window_t screen_window;
+    screen_event_t screen_event;
+#endif
+    WSI_PLATFORM wsi_platform;
+    VkSurfaceKHR surface;
+    bool initialized;
+    bool swapchain_ready;
+    bool is_minimized;
+    bool use_staging_buffer;
+    bool separate_present_queue;
+    bool invalid_gpu_selection;
+    int32_t gpu_number;
+
+    bool VK_KHR_incremental_present_enabled;
+
+    bool VK_GOOGLE_display_timing_enabled;
+    bool syncd_with_actual_presents;
+    uint64_t refresh_duration;
+    uint64_t refresh_duration_multiplier;
+    uint64_t target_IPD;  // image present duration (inverse of frame rate)
+    uint64_t prev_desired_present_time;
+    uint32_t next_present_id;
+    uint32_t last_early_id;  // 0 if no early images
+    uint32_t last_late_id;   // 0 if no late images
+
+    VkInstance inst;
+    VkPhysicalDevice gpu;
+    VkDevice device;
+    VkQueue graphics_queue;
+    VkQueue present_queue;
+    uint32_t graphics_queue_family_index;
+    uint32_t present_queue_family_index;
+    VkPhysicalDeviceProperties gpu_props;
+    VkQueueFamilyProperties *queue_props;
+    VkPhysicalDeviceMemoryProperties memory_properties;
+    SubmissionResources submission_resources[FRAME_LAG];
+    uint32_t current_submission_index;
+
+    uint32_t enabled_extension_count;
+    uint32_t enabled_layer_count;
+    char *extension_names[64];
+    char *enabled_layers[64];
+
+    int width, height;
+    VkFormat format;
+    VkColorSpaceKHR color_space;
+
+    uint32_t swapchainImageCount;
+    VkSwapchainKHR swapchain;
+    SwapchainImageResources swapchain_resources[MAX_SWAPCHAIN_IMAGE_COUNT];
+    VkPresentModeKHR presentMode;
+    bool first_swapchain_frame;
+
+    VkCommandPool cmd_pool;
+    VkCommandPool present_cmd_pool;
+
+    struct {
+        VkFormat format;
+
+        VkImage image;
+        VkMemoryAllocateInfo mem_alloc;
+        VkDeviceMemory mem;
+        VkImageView view;
+    } depth;
+
+    struct texture_object textures[DEMO_TEXTURE_COUNT];
+    struct texture_object staging_texture;
+
+    VkCommandBuffer cmd;  // Buffer for initialization commands
+    VkPipelineLayout pipeline_layout;
+    VkDescriptorSetLayout desc_layout;
+    VkPipelineCache pipelineCache;
+    VkRenderPass render_pass;
+    VkPipeline pipeline;
+
+    mat4x4 projection_matrix;
+    mat4x4 view_matrix;
+    mat4x4 model_matrix;
+
+    float spin_angle;
+    float spin_increment;
+    bool pause;
+
+    VkShaderModule vert_shader_module;
+    VkShaderModule frag_shader_module;
+
+    VkDescriptorPool desc_pool;
+
+    bool quit;
+    int32_t curFrame;
+    int32_t frameCount;
+    bool validate;
+    bool use_break;
+    bool suppress_popups;
+    bool force_errors;
+
+    VkDebugUtilsMessengerEXT dbg_messenger;
+
+    uint32_t queue_family_count;
+};
+
+VKAPI_ATTR VkBool32 VKAPI_CALL debug_messenger_callback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+                                                        VkDebugUtilsMessageTypeFlagsEXT messageType,
+                                                        const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData,
+                                                        void *pUserData) {
+    char prefix[64] = "";
+    char *message = (char *)malloc(strlen(pCallbackData->pMessage) + 5000);
+    assert(message);
+    struct demo *demo = (struct demo *)pUserData;
+
+    if (demo->use_break) {
+#ifndef WIN32
+        raise(SIGTRAP);
+#else
+        DebugBreak();
+#endif
+    }
+
+    if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) {
+        strcat(prefix, "VERBOSE : ");
+    } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT) {
+        strcat(prefix, "INFO : ");
+    } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) {
+        strcat(prefix, "WARNING : ");
+    } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
+        strcat(prefix, "ERROR : ");
+    }
+
+    if (messageType & VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT) {
+        strcat(prefix, "GENERAL");
+    } else {
+        if (messageType & VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT) {
+            strcat(prefix, "VALIDATION");
+            validation_error = 1;
+        }
+        if (messageType & VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT) {
+            if (messageType & VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT) {
+                strcat(prefix, "|");
+            }
+            strcat(prefix, "PERFORMANCE");
+        }
+    }
+
+    sprintf(message, "%s - Message Id Number: %d | Message Id Name: %s\n\t%s\n", prefix, pCallbackData->messageIdNumber,
+            pCallbackData->pMessageIdName == NULL ? "" : pCallbackData->pMessageIdName, pCallbackData->pMessage);
+    if (pCallbackData->objectCount > 0) {
+        char tmp_message[500];
+        sprintf(tmp_message, "\n\tObjects - %d\n", pCallbackData->objectCount);
+        strcat(message, tmp_message);
+        for (uint32_t object = 0; object < pCallbackData->objectCount; ++object) {
+            sprintf(tmp_message, "\t\tObject[%d] - %s", object, string_VkObjectType(pCallbackData->pObjects[object].objectType));
+            strcat(message, tmp_message);
+
+            VkObjectType t = pCallbackData->pObjects[object].objectType;
+            if (t == VK_OBJECT_TYPE_INSTANCE || t == VK_OBJECT_TYPE_PHYSICAL_DEVICE || t == VK_OBJECT_TYPE_DEVICE ||
+                t == VK_OBJECT_TYPE_COMMAND_BUFFER || t == VK_OBJECT_TYPE_QUEUE) {
+                sprintf(tmp_message, ", Handle %p", (void *)(uintptr_t)(pCallbackData->pObjects[object].objectHandle));
+                strcat(message, tmp_message);
+            } else {
+                sprintf(tmp_message, ", Handle Ox%" PRIx64, (pCallbackData->pObjects[object].objectHandle));
+                strcat(message, tmp_message);
+            }
+
+            if (NULL != pCallbackData->pObjects[object].pObjectName && strlen(pCallbackData->pObjects[object].pObjectName) > 0) {
+                sprintf(tmp_message, ", Name \"%s\"", pCallbackData->pObjects[object].pObjectName);
+                strcat(message, tmp_message);
+            }
+            sprintf(tmp_message, "\n");
+            strcat(message, tmp_message);
+        }
+    }
+    if (pCallbackData->cmdBufLabelCount > 0) {
+        char tmp_message[500];
+        sprintf(tmp_message, "\n\tCommand Buffer Labels - %d\n", pCallbackData->cmdBufLabelCount);
+        strcat(message, tmp_message);
+        for (uint32_t cmd_buf_label = 0; cmd_buf_label < pCallbackData->cmdBufLabelCount; ++cmd_buf_label) {
+            sprintf(tmp_message, "\t\tLabel[%d] - %s { %f, %f, %f, %f}\n", cmd_buf_label,
+                    pCallbackData->pCmdBufLabels[cmd_buf_label].pLabelName, pCallbackData->pCmdBufLabels[cmd_buf_label].color[0],
+                    pCallbackData->pCmdBufLabels[cmd_buf_label].color[1], pCallbackData->pCmdBufLabels[cmd_buf_label].color[2],
+                    pCallbackData->pCmdBufLabels[cmd_buf_label].color[3]);
+            strcat(message, tmp_message);
+        }
+    }
+
+#ifdef _WIN32
+
+    in_callback = true;
+    if (!demo->suppress_popups) MessageBox(NULL, message, "Alert", MB_OK);
+    in_callback = false;
+
+#elif defined(ANDROID)
+
+    if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT) {
+        __android_log_print(ANDROID_LOG_INFO, APP_SHORT_NAME, "%s", message);
+    } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) {
+        __android_log_print(ANDROID_LOG_WARN, APP_SHORT_NAME, "%s", message);
+    } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
+        __android_log_print(ANDROID_LOG_ERROR, APP_SHORT_NAME, "%s", message);
+    } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) {
+        __android_log_print(ANDROID_LOG_VERBOSE, APP_SHORT_NAME, "%s", message);
+    } else {
+        __android_log_print(ANDROID_LOG_INFO, APP_SHORT_NAME, "%s", message);
+    }
+
+#else
+
+    printf("%s\n", message);
+    fflush(stdout);
+
+#endif
+
+    free(message);
+
+    // Don't bail out, but keep going.
+    return false;
+}
+
+bool ActualTimeLate(uint64_t desired, uint64_t actual, uint64_t rdur) {
+    // The desired time was the earliest time that the present should have
+    // occured.  In almost every case, the actual time should be later than the
+    // desired time.  We should only consider the actual time "late" if it is
+    // after "desired + rdur".
+    if (actual <= desired) {
+        // The actual time was before or equal to the desired time.  This will
+        // probably never happen, but in case it does, return false since the
+        // present was obviously NOT late.
+        return false;
+    }
+    uint64_t deadline = desired + rdur;
+    if (actual > deadline) {
+        return true;
+    } else {
+        return false;
+    }
+}
+bool CanPresentEarlier(uint64_t earliest, uint64_t actual, uint64_t margin, uint64_t rdur) {
+    if (earliest < actual) {
+        // Consider whether this present could have occured earlier.  Make sure
+        // that earliest time was at least 2msec earlier than actual time, and
+        // that the margin was at least 2msec:
+        uint64_t diff = actual - earliest;
+        if ((diff >= (2 * MILLION)) && (margin >= (2 * MILLION))) {
+            // This present could have occured earlier because both: 1) the
+            // earliest time was at least 2 msec before actual time, and 2) the
+            // margin was at least 2msec.
+            return true;
+        }
+    }
+    return false;
+}
+
+// Forward declarations:
+static void demo_resize(struct demo *demo);
+
+static void demo_create_surface(struct demo *demo);
+
+#if defined(__GNUC__) || defined(__clang__)
+#define DECORATE_PRINTF(_fmt_argnum, _first_param_num) __attribute__((format(printf, _fmt_argnum, _first_param_num)))
+#else
+#define DECORATE_PRINTF(_fmt_num, _first_param_num)
+#endif
+
+DECORATE_PRINTF(4, 5)
+static void demo_name_object(struct demo *demo, VkObjectType object_type, uint64_t vulkan_handle, const char *format, ...) {
+    if (!demo->validate) {
+        return;
+    }
+    VkResult U_ASSERT_ONLY err;
+    char name[1024];
+    va_list argptr;
+    va_start(argptr, format);
+    vsnprintf(name, sizeof(name), format, argptr);
+    va_end(argptr);
+    name[sizeof(name) - 1] = '\0';
+
+    VkDebugUtilsObjectNameInfoEXT obj_name = {
+        .sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
+        .pNext = NULL,
+        .objectType = object_type,
+        .objectHandle = vulkan_handle,
+        .pObjectName = name,
+    };
+    err = vkSetDebugUtilsObjectNameEXT(demo->device, &obj_name);
+    assert(!err);
+}
+
+DECORATE_PRINTF(4, 5)
+static void demo_push_cb_label(struct demo *demo, VkCommandBuffer cb, const float *color, const char *format, ...) {
+    if (!demo->validate) {
+        return;
+    }
+    char name[1024];
+    va_list argptr;
+    va_start(argptr, format);
+    vsnprintf(name, sizeof(name), format, argptr);
+    va_end(argptr);
+    name[sizeof(name) - 1] = '\0';
+
+    VkDebugUtilsLabelEXT label = {
+        .sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT,
+        .pNext = NULL,
+        .pLabelName = name,
+    };
+    if (color) {
+        memcpy(label.color, color, sizeof(label.color));
+    }
+
+    vkCmdBeginDebugUtilsLabelEXT(cb, &label);
+}
+
+static void demo_pop_cb_label(struct demo *demo, VkCommandBuffer cb) {
+    if (!demo->validate) {
+        return;
+    }
+    vkCmdEndDebugUtilsLabelEXT(cb);
+}
+
+static bool memory_type_from_properties(struct demo *demo, uint32_t typeBits, VkFlags requirements_mask, uint32_t *typeIndex) {
+    // Search memtypes to find first index with those properties
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++) {
+        if ((typeBits & 1) == 1) {
+            // Type is available, does it match user properties?
+            if ((demo->memory_properties.memoryTypes[i].propertyFlags & requirements_mask) == requirements_mask) {
+                *typeIndex = i;
+                return true;
+            }
+        }
+        typeBits >>= 1;
+    }
+    // No memory types matched, return failure
+    return false;
+}
+
+static void demo_flush_init_cmd(struct demo *demo) {
+    VkResult U_ASSERT_ONLY err;
+
+    // This function could get called twice if the texture uses a staging buffer
+    // In that case the second call should be ignored
+    if (demo->cmd == VK_NULL_HANDLE) return;
+
+    err = vkEndCommandBuffer(demo->cmd);
+    assert(!err);
+
+    VkFence fence;
+    VkFenceCreateInfo fence_ci = {.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, .pNext = NULL, .flags = 0};
+    if (demo->force_errors) {
+        // Remove sType to intentionally force validation layer errors.
+        fence_ci.sType = 0;
+    }
+    err = vkCreateFence(demo->device, &fence_ci, NULL, &fence);
+    assert(!err);
+    demo_name_object(demo, VK_OBJECT_TYPE_FENCE, (uint64_t)fence, "InitFence");
+
+    const VkCommandBuffer cmd_bufs[] = {demo->cmd};
+    VkSubmitInfo submit_info = {.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
+                                .pNext = NULL,
+                                .waitSemaphoreCount = 0,
+                                .pWaitSemaphores = NULL,
+                                .pWaitDstStageMask = NULL,
+                                .commandBufferCount = 1,
+                                .pCommandBuffers = cmd_bufs,
+                                .signalSemaphoreCount = 0,
+                                .pSignalSemaphores = NULL};
+
+    err = vkQueueSubmit(demo->graphics_queue, 1, &submit_info, fence);
+    assert(!err);
+
+    err = vkWaitForFences(demo->device, 1, &fence, VK_TRUE, UINT64_MAX);
+    assert(!err);
+
+    vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, cmd_bufs);
+    vkDestroyFence(demo->device, fence, NULL);
+    demo->cmd = VK_NULL_HANDLE;
+}
+
+static void demo_set_image_layout(struct demo *demo, VkImage image, VkImageAspectFlags aspectMask, VkImageLayout old_image_layout,
+                                  VkImageLayout new_image_layout, VkAccessFlagBits srcAccessMask, VkPipelineStageFlags src_stages,
+                                  VkPipelineStageFlags dest_stages) {
+    assert(demo->cmd);
+
+    VkImageMemoryBarrier image_memory_barrier = {.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+                                                 .pNext = NULL,
+                                                 .srcAccessMask = srcAccessMask,
+                                                 .dstAccessMask = 0,
+                                                 .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                                                 .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+                                                 .oldLayout = old_image_layout,
+                                                 .newLayout = new_image_layout,
+                                                 .image = image,
+                                                 .subresourceRange = {aspectMask, 0, 1, 0, 1}};
+
+    switch (new_image_layout) {
+        case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
+            /* Make sure anything that was copying from this image has completed */
+            image_memory_barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+            break;
+
+        case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+            image_memory_barrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+            break;
+
+        case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+            image_memory_barrier.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+            break;
+
+        case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+            image_memory_barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
+            break;
+
+        case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
+            image_memory_barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
+            break;
+
+        case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:
+            image_memory_barrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
+            break;
+
+        default:
+            image_memory_barrier.dstAccessMask = 0;
+            break;
+    }
+
+    VkImageMemoryBarrier *pmemory_barrier = &image_memory_barrier;
+
+    vkCmdPipelineBarrier(demo->cmd, src_stages, dest_stages, 0, 0, NULL, 0, NULL, 1, pmemory_barrier);
+}
+
+static void demo_draw_build_cmd(struct demo *demo, SubmissionResources *submission_resource,
+                                SwapchainImageResources *swapchain_resource) {
+    const VkCommandBufferBeginInfo cmd_buf_info = {
+        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+        .pNext = NULL,
+        .flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
+        .pInheritanceInfo = NULL,
+    };
+    const VkClearValue clear_values[2] = {
+        [0] = {.color.float32 = {0.2f, 0.2f, 0.2f, 0.2f}},
+        [1] = {.depthStencil = {1.0f, 0}},
+    };
+    const VkRenderPassBeginInfo rp_begin = {
+        .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
+        .pNext = NULL,
+        .renderPass = demo->render_pass,
+        .framebuffer = swapchain_resource->framebuffer,
+        .renderArea.offset.x = 0,
+        .renderArea.offset.y = 0,
+        .renderArea.extent.width = demo->width,
+        .renderArea.extent.height = demo->height,
+        .clearValueCount = 2,
+        .pClearValues = clear_values,
+    };
+    VkResult U_ASSERT_ONLY err;
+
+    err = vkResetCommandBuffer(submission_resource->cmd, 0 /* VK_COMMAND_BUFFER_RESET_FLAGS */);
+    err = vkBeginCommandBuffer(submission_resource->cmd, &cmd_buf_info);
+
+    demo_name_object(demo, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)submission_resource->cmd, "CubeDrawCommandBuf");
+
+    const float begin_color[4] = {0.4f, 0.3f, 0.2f, 0.1f};
+    demo_push_cb_label(demo, submission_resource->cmd, begin_color, "DrawBegin");
+
+    assert(!err);
+    vkCmdBeginRenderPass(submission_resource->cmd, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
+
+    const float renderpass_color[4] = {8.4f, 7.3f, 6.2f, 7.1f};
+    demo_push_cb_label(demo, submission_resource->cmd, renderpass_color, "InsideRenderPass");
+
+    vkCmdBindPipeline(submission_resource->cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, demo->pipeline);
+    vkCmdBindDescriptorSets(submission_resource->cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, demo->pipeline_layout, 0, 1,
+                            &submission_resource->descriptor_set, 0, NULL);
+    VkViewport viewport;
+    memset(&viewport, 0, sizeof(viewport));
+    float viewport_dimension;
+    if (demo->width < demo->height) {
+        viewport_dimension = (float)demo->width;
+        viewport.y = (demo->height - demo->width) / 2.0f;
+    } else {
+        viewport_dimension = (float)demo->height;
+        viewport.x = (demo->width - demo->height) / 2.0f;
+    }
+    viewport.height = viewport_dimension;
+    viewport.width = viewport_dimension;
+    viewport.minDepth = (float)0.0f;
+    viewport.maxDepth = (float)1.0f;
+    vkCmdSetViewport(submission_resource->cmd, 0, 1, &viewport);
+
+    VkRect2D scissor;
+    memset(&scissor, 0, sizeof(scissor));
+    scissor.extent.width = demo->width;
+    scissor.extent.height = demo->height;
+    scissor.offset.x = 0;
+    scissor.offset.y = 0;
+    vkCmdSetScissor(submission_resource->cmd, 0, 1, &scissor);
+
+    const float draw_color[4] = {-0.4f, -0.3f, -0.2f, -0.1f};
+    demo_push_cb_label(demo, submission_resource->cmd, draw_color, "ActualDraw");
+    vkCmdDraw(submission_resource->cmd, 12 * 3, 1, 0, 0);
+    demo_pop_cb_label(demo, submission_resource->cmd);
+
+    // Note that ending the renderpass changes the image's layout from
+    // COLOR_ATTACHMENT_OPTIMAL to PRESENT_SRC_KHR
+    vkCmdEndRenderPass(submission_resource->cmd);
+    demo_pop_cb_label(demo, submission_resource->cmd);
+
+    if (demo->separate_present_queue) {
+        // We have to transfer ownership from the graphics queue family to the
+        // present queue family to be able to present.  Note that we don't have
+        // to transfer from present queue family back to graphics queue family at
+        // the start of the next frame because we don't care about the image's
+        // contents at that point.
+        VkImageMemoryBarrier image_ownership_barrier = {.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+                                                        .pNext = NULL,
+                                                        .srcAccessMask = 0,
+                                                        .dstAccessMask = 0,
+                                                        .oldLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
+                                                        .newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
+                                                        .srcQueueFamilyIndex = demo->graphics_queue_family_index,
+                                                        .dstQueueFamilyIndex = demo->present_queue_family_index,
+                                                        .image = swapchain_resource->image,
+                                                        .subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}};
+
+        vkCmdPipelineBarrier(submission_resource->cmd, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+                             0, 0, NULL, 0, NULL, 1, &image_ownership_barrier);
+    }
+    demo_pop_cb_label(demo, submission_resource->cmd);
+    err = vkEndCommandBuffer(submission_resource->cmd);
+    assert(!err);
+}
+
+void demo_build_image_ownership_cmd(struct demo *demo, SubmissionResources *submission_resource,
+                                    SwapchainImageResources *swapchain_resource) {
+    VkResult U_ASSERT_ONLY err;
+
+    err = vkResetCommandBuffer(submission_resource->graphics_to_present_cmd, 0 /* VK_COMMAND_BUFFER_RESET_FLAGS */);
+    assert(!err);
+
+    const VkCommandBufferBeginInfo cmd_buf_info = {
+        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+        .pNext = NULL,
+        .flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
+        .pInheritanceInfo = NULL,
+    };
+    err = vkBeginCommandBuffer(submission_resource->graphics_to_present_cmd, &cmd_buf_info);
+    assert(!err);
+
+    VkImageMemoryBarrier image_ownership_barrier = {.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+                                                    .pNext = NULL,
+                                                    .srcAccessMask = 0,
+                                                    .dstAccessMask = 0,
+                                                    .oldLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
+                                                    .newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
+                                                    .srcQueueFamilyIndex = demo->graphics_queue_family_index,
+                                                    .dstQueueFamilyIndex = demo->present_queue_family_index,
+                                                    .image = swapchain_resource->image,
+                                                    .subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}};
+
+    vkCmdPipelineBarrier(submission_resource->graphics_to_present_cmd, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+                         VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, NULL, 0, NULL, 1, &image_ownership_barrier);
+    err = vkEndCommandBuffer(submission_resource->graphics_to_present_cmd);
+    assert(!err);
+}
+
+void demo_update_data_buffer(struct demo *demo, void *uniform_memory_ptr) {
+    mat4x4 MVP, Model, VP;
+    int matrixSize = sizeof(MVP);
+
+    mat4x4_mul(VP, demo->projection_matrix, demo->view_matrix);
+
+    // Rotate around the Y axis
+    mat4x4_dup(Model, demo->model_matrix);
+    mat4x4_rotate_Y(demo->model_matrix, Model, (float)degreesToRadians(demo->spin_angle));
+    mat4x4_orthonormalize(demo->model_matrix, demo->model_matrix);
+    mat4x4_mul(MVP, VP, demo->model_matrix);
+
+    memcpy(uniform_memory_ptr, (const void *)&MVP[0][0], matrixSize);
+}
+
+void DemoUpdateTargetIPD(struct demo *demo) {
+    // Look at what happened to previous presents, and make appropriate
+    // adjustments in timing:
+    VkResult U_ASSERT_ONLY err;
+    VkPastPresentationTimingGOOGLE *past = NULL;
+    uint32_t count = 0;
+
+    err = vkGetPastPresentationTimingGOOGLE(demo->device, demo->swapchain, &count, NULL);
+    assert(!err);
+    if (count) {
+        past = (VkPastPresentationTimingGOOGLE *)malloc(sizeof(VkPastPresentationTimingGOOGLE) * count);
+        assert(past);
+        err = vkGetPastPresentationTimingGOOGLE(demo->device, demo->swapchain, &count, past);
+        assert(!err);
+
+        bool early = false;
+        bool late = false;
+        bool calibrate_next = false;
+        for (uint32_t i = 0; i < count; i++) {
+            if (!demo->syncd_with_actual_presents) {
+                // This is the first time that we've received an
+                // actualPresentTime for this swapchain.  In order to not
+                // perceive these early frames as "late", we need to sync-up
+                // our future desiredPresentTime's with the
+                // actualPresentTime(s) that we're receiving now.
+                calibrate_next = true;
+
+                // So that we don't suspect any pending presents as late,
+                // record them all as suspected-late presents:
+                demo->last_late_id = demo->next_present_id - 1;
+                demo->last_early_id = 0;
+                demo->syncd_with_actual_presents = true;
+                break;
+            } else if (CanPresentEarlier(past[i].earliestPresentTime, past[i].actualPresentTime, past[i].presentMargin,
+                                         demo->refresh_duration)) {
+                // This image could have been presented earlier.  We don't want
+                // to decrease the target_IPD until we've seen early presents
+                // for at least two seconds.
+                if (demo->last_early_id == past[i].presentID) {
+                    // We've now seen two seconds worth of early presents.
+                    // Flag it as such, and reset the counter:
+                    early = true;
+                    demo->last_early_id = 0;
+                } else if (demo->last_early_id == 0) {
+                    // This is the first early present we've seen.
+                    // Calculate the presentID for two seconds from now.
+                    uint64_t lastEarlyTime = past[i].actualPresentTime + (2 * BILLION);
+                    uint32_t howManyPresents = (uint32_t)((lastEarlyTime - past[i].actualPresentTime) / demo->target_IPD);
+                    demo->last_early_id = past[i].presentID + howManyPresents;
+                } else {
+                    // We are in the midst of a set of early images,
+                    // and so we won't do anything.
+                }
+                late = false;
+                demo->last_late_id = 0;
+            } else if (ActualTimeLate(past[i].desiredPresentTime, past[i].actualPresentTime, demo->refresh_duration)) {
+                // This image was presented after its desired time.  Since
+                // there's a delay between calling vkQueuePresentKHR and when
+                // we get the timing data, several presents may have been late.
+                // Thus, we need to threat all of the outstanding presents as
+                // being likely late, so that we only increase the target_IPD
+                // once for all of those presents.
+                if ((demo->last_late_id == 0) || (demo->last_late_id < past[i].presentID)) {
+                    late = true;
+                    // Record the last suspected-late present:
+                    demo->last_late_id = demo->next_present_id - 1;
+                } else {
+                    // We are in the midst of a set of likely-late images,
+                    // and so we won't do anything.
+                }
+                early = false;
+                demo->last_early_id = 0;
+            } else {
+                // Since this image was not presented early or late, reset
+                // any sets of early or late presentIDs:
+                early = false;
+                late = false;
+                calibrate_next = true;
+                demo->last_early_id = 0;
+                demo->last_late_id = 0;
+            }
+        }
+
+        if (early) {
+            // Since we've seen at least two-seconds worth of presnts that
+            // could have occured earlier than desired, let's decrease the
+            // target_IPD (i.e. increase the frame rate):
+            //
+            // TODO(ianelliott): Try to calculate a better target_IPD based
+            // on the most recently-seen present (this is overly-simplistic).
+            demo->refresh_duration_multiplier--;
+            if (demo->refresh_duration_multiplier == 0) {
+                // This should never happen, but in case it does, don't
+                // try to go faster.
+                demo->refresh_duration_multiplier = 1;
+            }
+            demo->target_IPD = demo->refresh_duration * demo->refresh_duration_multiplier;
+        }
+        if (late) {
+            // Since we found a new instance of a late present, we want to
+            // increase the target_IPD (i.e. decrease the frame rate):
+            //
+            // TODO(ianelliott): Try to calculate a better target_IPD based
+            // on the most recently-seen present (this is overly-simplistic).
+            demo->refresh_duration_multiplier++;
+            demo->target_IPD = demo->refresh_duration * demo->refresh_duration_multiplier;
+        }
+
+        if (calibrate_next) {
+            int64_t multiple = demo->next_present_id - past[count - 1].presentID - 1;
+            demo->prev_desired_present_time = (past[count - 1].actualPresentTime + (multiple * demo->target_IPD));
+        }
+        free(past);
+    }
+}
+
+static void demo_draw(struct demo *demo) {
+    // Don't draw if initialization isn't complete, if the swapchain became outdated, or if the window is minimized
+    if (!demo->initialized || !demo->swapchain_ready || demo->is_minimized) {
+        return;
+    }
+
+    VkResult U_ASSERT_ONLY err;
+
+    SubmissionResources current_submission = demo->submission_resources[demo->current_submission_index];
+
+    // Ensure no more than FRAME_LAG renderings are outstanding
+    vkWaitForFences(demo->device, 1, &current_submission.fence, VK_TRUE, UINT64_MAX);
+
+    uint32_t current_swapchain_image_index;
+    do {
+        // Get the index of the next available swapchain image:
+        err = vkAcquireNextImageKHR(demo->device, demo->swapchain, UINT64_MAX, current_submission.image_acquired_semaphore,
+                                    VK_NULL_HANDLE, &current_swapchain_image_index);
+
+        if (err == VK_ERROR_OUT_OF_DATE_KHR) {
+            // demo->swapchain is out of date (e.g. the window was resized) and
+            // must be recreated:
+            demo_resize(demo);
+        } else if (err == VK_SUBOPTIMAL_KHR) {
+            // demo->swapchain is not as optimal as it could be, but the platform's
+            // presentation engine will still present the image correctly.
+            break;
+        } else if (err == VK_ERROR_SURFACE_LOST_KHR) {
+            vkDestroySurfaceKHR(demo->inst, demo->surface, NULL);
+            demo_create_surface(demo);
+            demo_resize(demo);
+        } else {
+            assert(!err);
+        }
+
+        // Stop drawing if we resized but didn't successfully create a new swapchain.
+        if (!demo->swapchain_ready) {
+            return;
+        }
+    } while (err != VK_SUCCESS);
+
+    SwapchainImageResources current_swapchain_resource = demo->swapchain_resources[current_swapchain_image_index];
+
+    demo_update_data_buffer(demo, current_submission.uniform_memory_ptr);
+
+    if (demo->VK_GOOGLE_display_timing_enabled) {
+        // Look at what happened to previous presents, and make appropriate
+        // adjustments in timing:
+        DemoUpdateTargetIPD(demo);
+
+        // Note: a real application would position its geometry to that it's in
+        // the correct locatoin for when the next image is presented.  It might
+        // also wait, so that there's less latency between any input and when
+        // the next image is rendered/presented.  This demo program is so
+        // simple that it doesn't do either of those.
+    }
+
+    demo_draw_build_cmd(demo, &current_submission, &current_swapchain_resource);
+
+    if (demo->separate_present_queue) {
+        demo_build_image_ownership_cmd(demo, &current_submission, &current_swapchain_resource);
+    }
+
+    // Only reset right before submitting so we can't deadlock on an un-signalled fence that has nothing submitted to it
+    vkResetFences(demo->device, 1, &current_submission.fence);
+
+    // Wait for the image acquired semaphore to be signaled to ensure
+    // that the image won't be rendered to until the presentation
+    // engine has fully released ownership to the application, and it is
+    // okay to render to the image.
+    VkPipelineStageFlags pipe_stage_flags;
+    VkSubmitInfo submit_info;
+    submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+    submit_info.pNext = NULL;
+    pipe_stage_flags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+    submit_info.pWaitDstStageMask = &pipe_stage_flags;
+    submit_info.waitSemaphoreCount = 1;
+    submit_info.pWaitSemaphores = &current_submission.image_acquired_semaphore;
+    submit_info.commandBufferCount = 1;
+    submit_info.pCommandBuffers = &current_submission.cmd;
+    submit_info.signalSemaphoreCount = 1;
+    submit_info.pSignalSemaphores = &current_swapchain_resource.draw_complete_semaphore;
+    err = vkQueueSubmit(demo->graphics_queue, 1, &submit_info, current_submission.fence);
+    assert(!err);
+
+    if (demo->separate_present_queue) {
+        // If we are using separate queues, change image ownership to the
+        // present queue before presenting, waiting for the draw complete
+        // semaphore and signalling the ownership released semaphore when finished
+        VkFence nullFence = VK_NULL_HANDLE;
+        pipe_stage_flags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+        submit_info.waitSemaphoreCount = 1;
+        submit_info.pWaitSemaphores = &current_swapchain_resource.draw_complete_semaphore;
+        submit_info.commandBufferCount = 1;
+        submit_info.pCommandBuffers = &current_submission.graphics_to_present_cmd;
+        submit_info.signalSemaphoreCount = 1;
+        submit_info.pSignalSemaphores = &current_swapchain_resource.image_ownership_semaphore;
+        err = vkQueueSubmit(demo->present_queue, 1, &submit_info, nullFence);
+        assert(!err);
+    }
+
+    // If we are using separate queues we have to wait for image ownership,
+    // otherwise wait for draw complete
+    VkPresentInfoKHR present = {
+        .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
+        .pNext = NULL,
+        .waitSemaphoreCount = 1,
+        .pWaitSemaphores = (demo->separate_present_queue) ? &current_swapchain_resource.image_ownership_semaphore
+                                                          : &current_swapchain_resource.draw_complete_semaphore,
+        .swapchainCount = 1,
+        .pSwapchains = &demo->swapchain,
+        .pImageIndices = &current_swapchain_image_index,
+    };
+
+    VkRectLayerKHR rect;
+    VkPresentRegionKHR region;
+    VkPresentRegionsKHR regions;
+    if (demo->VK_KHR_incremental_present_enabled) {
+        // If using VK_KHR_incremental_present, we provide a hint of the region
+        // that contains changed content relative to the previously-presented
+        // image.  The implementation can use this hint in order to save
+        // work/power (by only copying the region in the hint).  The
+        // implementation is free to ignore the hint though, and so we must
+        // ensure that the entire image has the correctly-drawn content.
+        uint32_t eighthOfWidth = demo->width / 8;
+        uint32_t eighthOfHeight = demo->height / 8;
+
+        if (demo->first_swapchain_frame) {
+            rect.offset.x = 0;
+            rect.offset.y = 0;
+            rect.extent.width = demo->width;
+            rect.extent.height = demo->height;
+        } else {
+            rect.offset.x = eighthOfWidth;
+            rect.offset.y = eighthOfHeight;
+            rect.extent.width = eighthOfWidth * 6;
+            rect.extent.height = eighthOfHeight * 6;
+        }
+        rect.layer = 0;
+
+        region.rectangleCount = 1;
+        region.pRectangles = &rect;
+
+        regions.sType = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR;
+        regions.pNext = present.pNext;
+        regions.swapchainCount = present.swapchainCount;
+        regions.pRegions = &region;
+        present.pNext = &regions;
+    }
+
+    VkPresentTimesInfoGOOGLE present_time;
+    VkPresentTimeGOOGLE ptime;
+    if (demo->VK_GOOGLE_display_timing_enabled) {
+        if (demo->prev_desired_present_time == 0) {
+            // This must be the first present for this swapchain.
+            //
+            // We don't know where we are relative to the presentation engine's
+            // display's refresh cycle.  We also don't know how long rendering
+            // takes.  Let's make a grossly-simplified assumption that the
+            // desiredPresentTime should be half way between now and
+            // now+target_IPD.  We will adjust over time.
+            uint64_t curtime = getTimeInNanoseconds();
+            if (curtime == 0) {
+                // Since we didn't find out the current time, don't give a
+                // desiredPresentTime:
+                ptime.desiredPresentTime = 0;
+            } else {
+                ptime.desiredPresentTime = curtime + (demo->target_IPD >> 1);
+            }
+        } else {
+            ptime.desiredPresentTime = (demo->prev_desired_present_time + demo->target_IPD);
+        }
+        ptime.presentID = demo->next_present_id++;
+        demo->prev_desired_present_time = ptime.desiredPresentTime;
+
+        present_time = (VkPresentTimesInfoGOOGLE){
+            .sType = VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE,
+            .pNext = present.pNext,
+            .swapchainCount = present.swapchainCount,
+            .pTimes = &ptime,
+        };
+
+        present.pNext = &present_time;
+    }
+
+    err = vkQueuePresentKHR(demo->present_queue, &present);
+    demo->current_submission_index += 1;
+    demo->current_submission_index %= FRAME_LAG;
+    demo->first_swapchain_frame = false;
+
+    if (err == VK_ERROR_OUT_OF_DATE_KHR) {
+        // demo->swapchain is out of date (e.g. the window was resized) and
+        // must be recreated:
+        demo_resize(demo);
+    } else if (err == VK_SUBOPTIMAL_KHR) {
+        // SUBOPTIMAL could be due to a resize
+        VkSurfaceCapabilitiesKHR surfCapabilities;
+        err = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(demo->gpu, demo->surface, &surfCapabilities);
+        assert(!err);
+        if (surfCapabilities.currentExtent.width != (uint32_t)demo->width ||
+            surfCapabilities.currentExtent.height != (uint32_t)demo->height) {
+            demo_resize(demo);
+        }
+    } else if (err == VK_ERROR_SURFACE_LOST_KHR) {
+        vkDestroySurfaceKHR(demo->inst, demo->surface, NULL);
+        demo_create_surface(demo);
+        demo_resize(demo);
+    } else {
+        assert(!err);
+    }
+}
+
+// Forward decls for that demo_prepare_swapchain needs
+static void demo_prepare_depth(struct demo *demo);
+static void demo_prepare_framebuffers(struct demo *demo);
+
+// Creates the swapchain, swapchain image views, depth buffer, framebuffers, and sempahores.
+// This function returns early if it fails to create a swapchain, setting swapchain_ready to false.
+static void demo_prepare_swapchain(struct demo *demo) {
+    VkResult U_ASSERT_ONLY err;
+    VkSwapchainKHR oldSwapchain = demo->swapchain;
+
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+    if (demo->wsi_platform == WSI_PLATFORM_WAYLAND && !demo->xdg_surface_has_been_configured) {
+        return;
+    }
+#endif
+
+    // Check the surface capabilities and formats
+    VkSurfaceCapabilitiesKHR surfCapabilities;
+    err = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(demo->gpu, demo->surface, &surfCapabilities);
+    assert(!err);
+
+    uint32_t presentModeCount;
+    err = vkGetPhysicalDeviceSurfacePresentModesKHR(demo->gpu, demo->surface, &presentModeCount, NULL);
+    assert(!err);
+    VkPresentModeKHR *presentModes = (VkPresentModeKHR *)malloc(presentModeCount * sizeof(VkPresentModeKHR));
+    assert(presentModes);
+    err = vkGetPhysicalDeviceSurfacePresentModesKHR(demo->gpu, demo->surface, &presentModeCount, presentModes);
+    assert(!err);
+
+    VkExtent2D swapchainExtent;
+    // width and height are either both 0xFFFFFFFF, or both not 0xFFFFFFFF.
+    if (surfCapabilities.currentExtent.width == 0xFFFFFFFF) {
+        // If the surface size is undefined, the size is set to the size
+        // of the images requested, which must fit within the minimum and
+        // maximum values.
+        swapchainExtent.width = demo->width;
+        swapchainExtent.height = demo->height;
+
+        if (swapchainExtent.width < surfCapabilities.minImageExtent.width) {
+            swapchainExtent.width = surfCapabilities.minImageExtent.width;
+        } else if (swapchainExtent.width > surfCapabilities.maxImageExtent.width) {
+            swapchainExtent.width = surfCapabilities.maxImageExtent.width;
+        }
+
+        if (swapchainExtent.height < surfCapabilities.minImageExtent.height) {
+            swapchainExtent.height = surfCapabilities.minImageExtent.height;
+        } else if (swapchainExtent.height > surfCapabilities.maxImageExtent.height) {
+            swapchainExtent.height = surfCapabilities.maxImageExtent.height;
+        }
+    } else {
+        // If the surface size is defined, the swap chain size must match
+        swapchainExtent = surfCapabilities.currentExtent;
+        demo->width = surfCapabilities.currentExtent.width;
+        demo->height = surfCapabilities.currentExtent.height;
+    }
+
+    if (surfCapabilities.maxImageExtent.width == 0 || surfCapabilities.maxImageExtent.height == 0) {
+        demo->is_minimized = true;
+        return;
+    } else {
+        demo->is_minimized = false;
+    }
+
+    // The FIFO present mode is guaranteed by the spec to be supported
+    // and to have no tearing.  It's a great default present mode to use.
+    VkPresentModeKHR swapchainPresentMode = VK_PRESENT_MODE_FIFO_KHR;
+
+    //  There are times when you may wish to use another present mode.  The
+    //  following code shows how to select them, and the comments provide some
+    //  reasons you may wish to use them.
+    //
+    // It should be noted that Vulkan 1.0 doesn't provide a method for
+    // synchronizing rendering with the presentation engine's display.  There
+    // is a method provided for throttling rendering with the display, but
+    // there are some presentation engines for which this method will not work.
+    // If an application doesn't throttle its rendering, and if it renders much
+    // faster than the refresh rate of the display, this can waste power on
+    // mobile devices.  That is because power is being spent rendering images
+    // that may never be seen.
+
+    // VK_PRESENT_MODE_IMMEDIATE_KHR is for applications that don't care about
+    // tearing, or have some way of synchronizing their rendering with the
+    // display.
+    // VK_PRESENT_MODE_MAILBOX_KHR may be useful for applications that
+    // generally render a new presentable image every refresh cycle, but are
+    // occasionally early.  In this case, the application wants the new image
+    // to be displayed instead of the previously-queued-for-presentation image
+    // that has not yet been displayed.
+    // VK_PRESENT_MODE_FIFO_RELAXED_KHR is for applications that generally
+    // render a new presentable image every refresh cycle, but are occasionally
+    // late.  In this case (perhaps because of stuttering/latency concerns),
+    // the application wants the late image to be immediately displayed, even
+    // though that may mean some tearing.
+
+    if (demo->presentMode != swapchainPresentMode) {
+        for (size_t i = 0; i < presentModeCount; ++i) {
+            if (presentModes[i] == demo->presentMode) {
+                swapchainPresentMode = demo->presentMode;
+                break;
+            }
+        }
+    }
+    if (swapchainPresentMode != demo->presentMode) {
+        ERR_EXIT("Present mode specified is not supported\n", "Present mode unsupported");
+    }
+
+    // Determine the number of VkImages to use in the swap chain.
+    // Application desires to acquire 3 images at a time for triple
+    // buffering
+    uint32_t desiredNumOfSwapchainImages = 3;
+    if (desiredNumOfSwapchainImages < surfCapabilities.minImageCount) {
+        desiredNumOfSwapchainImages = surfCapabilities.minImageCount;
+    }
+    // If maxImageCount is 0, we can ask for as many images as we want;
+    // otherwise we're limited to maxImageCount
+    if ((surfCapabilities.maxImageCount > 0) && (desiredNumOfSwapchainImages > surfCapabilities.maxImageCount)) {
+        // Application must settle for fewer images than desired:
+        desiredNumOfSwapchainImages = surfCapabilities.maxImageCount;
+    }
+
+    VkSurfaceTransformFlagsKHR preTransform;
+    if (surfCapabilities.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR) {
+        preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
+    } else {
+        preTransform = surfCapabilities.currentTransform;
+    }
+
+    // Find a supported composite alpha mode - one of these is guaranteed to be set
+    VkCompositeAlphaFlagBitsKHR compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
+    VkCompositeAlphaFlagBitsKHR compositeAlphaFlags[4] = {
+        VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
+        VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR,
+        VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR,
+        VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR,
+    };
+    for (uint32_t i = 0; i < ARRAY_SIZE(compositeAlphaFlags); i++) {
+        if (surfCapabilities.supportedCompositeAlpha & compositeAlphaFlags[i]) {
+            compositeAlpha = compositeAlphaFlags[i];
+            break;
+        }
+    }
+
+    VkSwapchainCreateInfoKHR swapchain_ci = {
+        .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
+        .pNext = NULL,
+        .surface = demo->surface,
+        .minImageCount = desiredNumOfSwapchainImages,
+        .imageFormat = demo->format,
+        .imageColorSpace = demo->color_space,
+        .imageExtent =
+            {
+                .width = swapchainExtent.width,
+                .height = swapchainExtent.height,
+            },
+        .imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
+        .preTransform = preTransform,
+        .compositeAlpha = compositeAlpha,
+        .imageArrayLayers = 1,
+        .imageSharingMode = VK_SHARING_MODE_EXCLUSIVE,
+        .queueFamilyIndexCount = 0,
+        .pQueueFamilyIndices = NULL,
+        .presentMode = swapchainPresentMode,
+        .oldSwapchain = oldSwapchain,
+        .clipped = true,
+    };
+    uint32_t i;
+    err = vkCreateSwapchainKHR(demo->device, &swapchain_ci, NULL, &demo->swapchain);
+    assert(!err);
+
+    // If we just re-created an existing swapchain, we should destroy the old
+    // swapchain at this point.
+    // Note: destroying the swapchain also cleans up all its associated
+    // presentable images once the platform is done with them.
+    if (oldSwapchain != VK_NULL_HANDLE) {
+        vkDestroySwapchainKHR(demo->device, oldSwapchain, NULL);
+    }
+
+    err = vkGetSwapchainImagesKHR(demo->device, demo->swapchain, &demo->swapchainImageCount, NULL);
+    assert(!err);
+
+    VkImage *swapchainImages = (VkImage *)malloc(demo->swapchainImageCount * sizeof(VkImage));
+    assert(swapchainImages);
+    err = vkGetSwapchainImagesKHR(demo->device, demo->swapchain, &demo->swapchainImageCount, swapchainImages);
+    assert(!err);
+
+    for (i = 0; i < demo->swapchainImageCount; i++) {
+        demo_name_object(demo, VK_OBJECT_TYPE_IMAGE, (uint64_t)swapchainImages[i], "SwapchainImage(%u)", i);
+    }
+    for (i = 0; i < demo->swapchainImageCount; i++) {
+        VkImageViewCreateInfo color_image_view = {
+            .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
+            .pNext = NULL,
+            .format = demo->format,
+            .components =
+                {
+                    .r = VK_COMPONENT_SWIZZLE_IDENTITY,
+                    .g = VK_COMPONENT_SWIZZLE_IDENTITY,
+                    .b = VK_COMPONENT_SWIZZLE_IDENTITY,
+                    .a = VK_COMPONENT_SWIZZLE_IDENTITY,
+                },
+            .subresourceRange =
+                {.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .baseMipLevel = 0, .levelCount = 1, .baseArrayLayer = 0, .layerCount = 1},
+            .viewType = VK_IMAGE_VIEW_TYPE_2D,
+            .flags = 0,
+        };
+
+        demo->swapchain_resources[i].image = swapchainImages[i];
+
+        color_image_view.image = demo->swapchain_resources[i].image;
+
+        err = vkCreateImageView(demo->device, &color_image_view, NULL, &demo->swapchain_resources[i].view);
+        assert(!err);
+        demo_name_object(demo, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t)demo->swapchain_resources[i].view, "SwapchainView(%u)", i);
+    }
+
+    // Create semaphores to synchronize acquiring presentable buffers before
+    // rendering and waiting for drawing to be complete before presenting
+    VkSemaphoreCreateInfo semaphoreCreateInfo = {
+        .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
+        .pNext = NULL,
+        .flags = 0,
+    };
+    for (i = 0; i < demo->swapchainImageCount; i++) {
+        err = vkCreateSemaphore(demo->device, &semaphoreCreateInfo, NULL, &demo->swapchain_resources[i].draw_complete_semaphore);
+        assert(!err);
+        demo_name_object(demo, VK_OBJECT_TYPE_SEMAPHORE, (uint64_t)demo->swapchain_resources[i].draw_complete_semaphore,
+                         "DrawCompleteSem(%u)", i);
+
+        if (demo->separate_present_queue) {
+            err = vkCreateSemaphore(demo->device, &semaphoreCreateInfo, NULL,
+                                    &demo->swapchain_resources[i].image_ownership_semaphore);
+            assert(!err);
+            demo_name_object(demo, VK_OBJECT_TYPE_SEMAPHORE, (uint64_t)demo->swapchain_resources[i].image_ownership_semaphore,
+                             "ImageOwnerSem(%u)", i);
+        }
+    }
+
+    if (demo->VK_GOOGLE_display_timing_enabled) {
+        VkRefreshCycleDurationGOOGLE rc_dur;
+        err = vkGetRefreshCycleDurationGOOGLE(demo->device, demo->swapchain, &rc_dur);
+        assert(!err);
+        demo->refresh_duration = rc_dur.refreshDuration;
+
+        demo->syncd_with_actual_presents = false;
+        // Initially target 1X the refresh duration:
+        demo->target_IPD = demo->refresh_duration;
+        demo->refresh_duration_multiplier = 1;
+        demo->prev_desired_present_time = 0;
+        demo->next_present_id = 1;
+    }
+
+    if (NULL != swapchainImages) {
+        free(swapchainImages);
+    }
+
+    if (NULL != presentModes) {
+        free(presentModes);
+    }
+
+    demo_prepare_depth(demo);
+    demo_prepare_framebuffers(demo);
+    demo->swapchain_ready = true;
+    demo->first_swapchain_frame = true;
+}
+
+static void demo_prepare_depth(struct demo *demo) {
+    demo->depth.format = VK_FORMAT_D16_UNORM;
+
+    const VkImageCreateInfo image = {
+        .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
+        .pNext = NULL,
+        .imageType = VK_IMAGE_TYPE_2D,
+        .format = demo->depth.format,
+        .extent = {demo->width, demo->height, 1},
+        .mipLevels = 1,
+        .arrayLayers = 1,
+        .samples = VK_SAMPLE_COUNT_1_BIT,
+        .tiling = VK_IMAGE_TILING_OPTIMAL,
+        .usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
+        .flags = 0,
+    };
+
+    VkImageViewCreateInfo view = {
+        .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
+        .pNext = NULL,
+        .image = VK_NULL_HANDLE,
+        .format = demo->depth.format,
+        .subresourceRange =
+            {.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT, .baseMipLevel = 0, .levelCount = 1, .baseArrayLayer = 0, .layerCount = 1},
+        .flags = 0,
+        .viewType = VK_IMAGE_VIEW_TYPE_2D,
+    };
+
+    if (demo->force_errors) {
+        // Intentionally force a bad pNext value to generate a validation layer error
+        view.pNext = &image;
+    }
+
+    VkMemoryRequirements mem_reqs;
+    VkResult U_ASSERT_ONLY err;
+    bool U_ASSERT_ONLY pass;
+
+    /* create image */
+    err = vkCreateImage(demo->device, &image, NULL, &demo->depth.image);
+    assert(!err);
+    demo_name_object(demo, VK_OBJECT_TYPE_IMAGE, (uint64_t)demo->depth.image, "DepthImage");
+
+    vkGetImageMemoryRequirements(demo->device, demo->depth.image, &mem_reqs);
+    assert(!err);
+
+    demo->depth.mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+    demo->depth.mem_alloc.pNext = NULL;
+    demo->depth.mem_alloc.allocationSize = mem_reqs.size;
+    demo->depth.mem_alloc.memoryTypeIndex = 0;
+
+    pass = memory_type_from_properties(demo, mem_reqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+                                       &demo->depth.mem_alloc.memoryTypeIndex);
+    assert(pass);
+
+    /* allocate memory */
+    err = vkAllocateMemory(demo->device, &demo->depth.mem_alloc, NULL, &demo->depth.mem);
+    assert(!err);
+    demo_name_object(demo, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)demo->depth.mem, "DepthMem");
+
+    /* bind memory */
+    err = vkBindImageMemory(demo->device, demo->depth.image, demo->depth.mem, 0);
+    assert(!err);
+
+    /* create image view */
+    view.image = demo->depth.image;
+    err = vkCreateImageView(demo->device, &view, NULL, &demo->depth.view);
+    assert(!err);
+    demo_name_object(demo, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t)demo->depth.view, "DepthView");
+}
+
+/* Convert ppm image data from header file into RGBA texture image */
+#include "lunarg.ppm.h"
+bool loadTexture(const char *filename, uint8_t *rgba_data, VkSubresourceLayout *layout, int32_t *width, int32_t *height) {
+    (void)filename;
+    char *cPtr;
+    cPtr = (char *)lunarg_ppm;
+    if ((unsigned char *)cPtr >= (lunarg_ppm + lunarg_ppm_len) || strncmp(cPtr, "P6\n", 3)) {
+        return false;
+    }
+    while (strncmp(cPtr++, "\n", 1));
+    sscanf(cPtr, "%u %u", width, height);
+    if (rgba_data == NULL) {
+        return true;
+    }
+    while (strncmp(cPtr++, "\n", 1));
+    if ((unsigned char *)cPtr >= (lunarg_ppm + lunarg_ppm_len) || strncmp(cPtr, "255\n", 4)) {
+        return false;
+    }
+    while (strncmp(cPtr++, "\n", 1));
+    for (int y = 0; y < *height; y++) {
+        uint8_t *rowPtr = rgba_data;
+        for (int x = 0; x < *width; x++) {
+            memcpy(rowPtr, cPtr, 3);
+            rowPtr[3] = 255; /* Alpha of 1 */
+            rowPtr += 4;
+            cPtr += 3;
+        }
+        rgba_data += layout->rowPitch;
+    }
+    return true;
+}
+
+static void demo_prepare_texture_buffer(struct demo *demo, const char *filename, struct texture_object *tex_obj) {
+    int32_t tex_width;
+    int32_t tex_height;
+    VkResult U_ASSERT_ONLY err;
+    bool U_ASSERT_ONLY pass;
+
+    if (!loadTexture(filename, NULL, NULL, &tex_width, &tex_height)) {
+        ERR_EXIT("Failed to load textures", "Load Texture Failure");
+    }
+
+    tex_obj->tex_width = tex_width;
+    tex_obj->tex_height = tex_height;
+
+    const VkBufferCreateInfo buffer_create_info = {.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+                                                   .pNext = NULL,
+                                                   .flags = 0,
+                                                   .size = tex_width * tex_height * 4,
+                                                   .usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+                                                   .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
+                                                   .queueFamilyIndexCount = 0,
+                                                   .pQueueFamilyIndices = NULL};
+
+    err = vkCreateBuffer(demo->device, &buffer_create_info, NULL, &tex_obj->buffer);
+    assert(!err);
+    demo_name_object(demo, VK_OBJECT_TYPE_BUFFER, (uint64_t)tex_obj->buffer, "TexBuffer(%s)", filename);
+
+    VkMemoryRequirements mem_reqs;
+    vkGetBufferMemoryRequirements(demo->device, tex_obj->buffer, &mem_reqs);
+
+    tex_obj->mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+    tex_obj->mem_alloc.pNext = NULL;
+    tex_obj->mem_alloc.allocationSize = mem_reqs.size;
+    tex_obj->mem_alloc.memoryTypeIndex = 0;
+
+    VkFlags requirements = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+    pass = memory_type_from_properties(demo, mem_reqs.memoryTypeBits, requirements, &tex_obj->mem_alloc.memoryTypeIndex);
+    assert(pass);
+
+    err = vkAllocateMemory(demo->device, &tex_obj->mem_alloc, NULL, &(tex_obj->mem));
+    assert(!err);
+    demo_name_object(demo, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)tex_obj->mem, "TexBufMemory(%s)", filename);
+
+    /* bind memory */
+    err = vkBindBufferMemory(demo->device, tex_obj->buffer, tex_obj->mem, 0);
+    assert(!err);
+
+    VkSubresourceLayout layout;
+    memset(&layout, 0, sizeof(layout));
+    layout.rowPitch = tex_width * 4;
+
+    void *data;
+    err = vkMapMemory(demo->device, tex_obj->mem, 0, tex_obj->mem_alloc.allocationSize, 0, &data);
+    assert(!err);
+
+    if (!loadTexture(filename, data, &layout, &tex_width, &tex_height)) {
+        fprintf(stderr, "Error loading texture: %s\n", filename);
+    }
+
+    vkUnmapMemory(demo->device, tex_obj->mem);
+}
+
+static void demo_prepare_texture_image(struct demo *demo, const char *filename, struct texture_object *tex_obj,
+                                       VkImageTiling tiling, VkImageUsageFlags usage, VkFlags required_props) {
+    const VkFormat tex_format = VK_FORMAT_R8G8B8A8_SRGB;
+    int32_t tex_width;
+    int32_t tex_height;
+    VkResult U_ASSERT_ONLY err;
+    bool U_ASSERT_ONLY pass;
+
+    if (!loadTexture(filename, NULL, NULL, &tex_width, &tex_height)) {
+        ERR_EXIT("Failed to load textures", "Load Texture Failure");
+    }
+
+    tex_obj->tex_width = tex_width;
+    tex_obj->tex_height = tex_height;
+
+    const VkImageCreateInfo image_create_info = {
+        .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
+        .pNext = NULL,
+        .imageType = VK_IMAGE_TYPE_2D,
+        .format = tex_format,
+        .extent = {tex_width, tex_height, 1},
+        .mipLevels = 1,
+        .arrayLayers = 1,
+        .samples = VK_SAMPLE_COUNT_1_BIT,
+        .tiling = tiling,
+        .usage = usage,
+        .flags = 0,
+        .initialLayout = VK_IMAGE_LAYOUT_PREINITIALIZED,
+    };
+
+    VkMemoryRequirements mem_reqs;
+
+    err = vkCreateImage(demo->device, &image_create_info, NULL, &tex_obj->image);
+    assert(!err);
+    demo_name_object(demo, VK_OBJECT_TYPE_IMAGE, (uint64_t)tex_obj->image, "TexImage(%s)", filename);
+
+    vkGetImageMemoryRequirements(demo->device, tex_obj->image, &mem_reqs);
+
+    tex_obj->mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+    tex_obj->mem_alloc.pNext = NULL;
+    tex_obj->mem_alloc.allocationSize = mem_reqs.size;
+    tex_obj->mem_alloc.memoryTypeIndex = 0;
+
+    pass = memory_type_from_properties(demo, mem_reqs.memoryTypeBits, required_props, &tex_obj->mem_alloc.memoryTypeIndex);
+    assert(pass);
+
+    /* allocate memory */
+    err = vkAllocateMemory(demo->device, &tex_obj->mem_alloc, NULL, &(tex_obj->mem));
+    assert(!err);
+    demo_name_object(demo, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)tex_obj->mem, "TexImageMem(%s)", filename);
+
+    /* bind memory */
+    err = vkBindImageMemory(demo->device, tex_obj->image, tex_obj->mem, 0);
+    assert(!err);
+
+    if (required_props & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) {
+        const VkImageSubresource subres = {
+            .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+            .mipLevel = 0,
+            .arrayLayer = 0,
+        };
+        VkSubresourceLayout layout;
+        void *data;
+
+        vkGetImageSubresourceLayout(demo->device, tex_obj->image, &subres, &layout);
+
+        err = vkMapMemory(demo->device, tex_obj->mem, 0, tex_obj->mem_alloc.allocationSize, 0, &data);
+        assert(!err);
+
+        if (!loadTexture(filename, data, &layout, &tex_width, &tex_height)) {
+            fprintf(stderr, "Error loading texture: %s\n", filename);
+        }
+
+        vkUnmapMemory(demo->device, tex_obj->mem);
+    }
+
+    tex_obj->imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+}
+
+static void demo_destroy_texture(struct demo *demo, struct texture_object *tex_objs) {
+    /* clean up staging resources */
+    vkFreeMemory(demo->device, tex_objs->mem, NULL);
+    if (tex_objs->image) vkDestroyImage(demo->device, tex_objs->image, NULL);
+    if (tex_objs->buffer) vkDestroyBuffer(demo->device, tex_objs->buffer, NULL);
+}
+
+static void demo_prepare_textures(struct demo *demo) {
+    const VkFormat tex_format = VK_FORMAT_R8G8B8A8_SRGB;
+    VkFormatProperties props;
+    uint32_t i;
+
+    vkGetPhysicalDeviceFormatProperties(demo->gpu, tex_format, &props);
+
+    for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
+        VkResult U_ASSERT_ONLY err;
+
+        if ((props.linearTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) && !demo->use_staging_buffer) {
+            demo_push_cb_label(demo, demo->cmd, NULL, "DirectTexture(%u)", i);
+            /* Device can texture using linear textures */
+            demo_prepare_texture_image(demo, tex_files[i], &demo->textures[i], VK_IMAGE_TILING_LINEAR, VK_IMAGE_USAGE_SAMPLED_BIT,
+                                       VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
+            // Nothing in the pipeline needs to be complete to start, and don't allow fragment
+            // shader to run until layout transition completes
+            demo_set_image_layout(demo, demo->textures[i].image, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_PREINITIALIZED,
+                                  demo->textures[i].imageLayout, 0, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+                                  VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
+            demo->staging_texture.image = 0;
+            demo_pop_cb_label(demo, demo->cmd);  // "DirectTexture"
+        } else if (props.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) {
+            /* Must use staging buffer to copy linear texture to optimized */
+            demo_push_cb_label(demo, demo->cmd, NULL, "StagingTexture(%u)", i);
+
+            memset(&demo->staging_texture, 0, sizeof(demo->staging_texture));
+            demo_prepare_texture_buffer(demo, tex_files[i], &demo->staging_texture);
+
+            demo_prepare_texture_image(demo, tex_files[i], &demo->textures[i], VK_IMAGE_TILING_OPTIMAL,
+                                       (VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT),
+                                       VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+
+            demo_set_image_layout(demo, demo->textures[i].image, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_PREINITIALIZED,
+                                  VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 0, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+                                  VK_PIPELINE_STAGE_TRANSFER_BIT);
+
+            demo_push_cb_label(demo, demo->cmd, NULL, "StagingBufferCopy(%u)", i);
+
+            VkBufferImageCopy copy_region = {
+                .bufferOffset = 0,
+                .bufferRowLength = demo->staging_texture.tex_width,
+                .bufferImageHeight = demo->staging_texture.tex_height,
+                .imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1},
+                .imageOffset = {0, 0, 0},
+                .imageExtent = {demo->staging_texture.tex_width, demo->staging_texture.tex_height, 1},
+            };
+
+            vkCmdCopyBufferToImage(demo->cmd, demo->staging_texture.buffer, demo->textures[i].image,
+                                   VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy_region);
+            demo_pop_cb_label(demo, demo->cmd);  // "StagingBufferCopy"
+
+            demo_set_image_layout(demo, demo->textures[i].image, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+                                  demo->textures[i].imageLayout, VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
+                                  VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
+            demo_pop_cb_label(demo, demo->cmd);  // "StagingTexture"
+
+        } else {
+            /* Can't support VK_FORMAT_R8G8B8A8_SRGB !? */
+            assert(!"No support for R8G8B8A8_SRGB as texture image format");
+        }
+
+        const VkSamplerCreateInfo sampler = {
+            .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
+            .pNext = NULL,
+            .magFilter = VK_FILTER_NEAREST,
+            .minFilter = VK_FILTER_NEAREST,
+            .mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST,
+            .addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
+            .addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
+            .addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
+            .mipLodBias = 0.0f,
+            .anisotropyEnable = VK_FALSE,
+            .maxAnisotropy = 1,
+            .compareOp = VK_COMPARE_OP_NEVER,
+            .minLod = 0.0f,
+            .maxLod = 0.0f,
+            .borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE,
+            .unnormalizedCoordinates = VK_FALSE,
+        };
+
+        VkImageViewCreateInfo view = {
+            .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
+            .pNext = NULL,
+            .image = VK_NULL_HANDLE,
+            .viewType = VK_IMAGE_VIEW_TYPE_2D,
+            .format = tex_format,
+            .components =
+                {
+                    VK_COMPONENT_SWIZZLE_IDENTITY,
+                    VK_COMPONENT_SWIZZLE_IDENTITY,
+                    VK_COMPONENT_SWIZZLE_IDENTITY,
+                    VK_COMPONENT_SWIZZLE_IDENTITY,
+                },
+            .subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1},
+            .flags = 0,
+        };
+
+        /* create sampler */
+        err = vkCreateSampler(demo->device, &sampler, NULL, &demo->textures[i].sampler);
+        assert(!err);
+        demo_name_object(demo, VK_OBJECT_TYPE_SAMPLER, (uint64_t)demo->textures[i].sampler, "Sampler(%u)", i);
+
+        /* create image view */
+        view.image = demo->textures[i].image;
+        err = vkCreateImageView(demo->device, &view, NULL, &demo->textures[i].view);
+        demo_name_object(demo, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t)demo->textures[i].view, "TexImageView(%u)", i);
+        assert(!err);
+    }
+}
+
+void demo_prepare_cube_data_buffers(struct demo *demo) {
+    VkBufferCreateInfo buf_info;
+    VkMemoryRequirements mem_reqs;
+    VkMemoryAllocateInfo mem_alloc;
+    mat4x4 MVP, VP;
+    VkResult U_ASSERT_ONLY err;
+    bool U_ASSERT_ONLY pass;
+    struct vktexcube_vs_uniform data;
+
+    mat4x4_mul(VP, demo->projection_matrix, demo->view_matrix);
+    mat4x4_mul(MVP, VP, demo->model_matrix);
+    memcpy(data.mvp, MVP, sizeof(MVP));
+    //    dumpMatrix("MVP", MVP);
+
+    for (unsigned int i = 0; i < 12 * 3; i++) {
+        data.position[i][0] = g_vertex_buffer_data[i * 3];
+        data.position[i][1] = g_vertex_buffer_data[i * 3 + 1];
+        data.position[i][2] = g_vertex_buffer_data[i * 3 + 2];
+        data.position[i][3] = 1.0f;
+        data.attr[i][0] = g_uv_buffer_data[2 * i];
+        data.attr[i][1] = g_uv_buffer_data[2 * i + 1];
+        data.attr[i][2] = 0;
+        data.attr[i][3] = 0;
+    }
+
+    memset(&buf_info, 0, sizeof(buf_info));
+    buf_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+    buf_info.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
+    buf_info.size = sizeof(data);
+
+    for (unsigned int i = 0; i < FRAME_LAG; i++) {
+        err = vkCreateBuffer(demo->device, &buf_info, NULL, &demo->submission_resources[i].uniform_buffer);
+        assert(!err);
+        demo_name_object(demo, VK_OBJECT_TYPE_BUFFER, (uint64_t)demo->submission_resources[i].uniform_buffer, "UniformBuf(%u)", i);
+
+        vkGetBufferMemoryRequirements(demo->device, demo->submission_resources[i].uniform_buffer, &mem_reqs);
+
+        mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+        mem_alloc.pNext = NULL;
+        mem_alloc.allocationSize = mem_reqs.size;
+        mem_alloc.memoryTypeIndex = 0;
+
+        pass = memory_type_from_properties(demo, mem_reqs.memoryTypeBits,
+                                           VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+                                           &mem_alloc.memoryTypeIndex);
+        assert(pass);
+
+        err = vkAllocateMemory(demo->device, &mem_alloc, NULL, &demo->submission_resources[i].uniform_memory);
+        assert(!err);
+        demo_name_object(demo, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)demo->submission_resources[i].uniform_memory,
+                         "UniformMem(%u)", i);
+
+        err = vkMapMemory(demo->device, demo->submission_resources[i].uniform_memory, 0, VK_WHOLE_SIZE, 0,
+                          &demo->submission_resources[i].uniform_memory_ptr);
+        assert(!err);
+
+        memcpy(demo->submission_resources[i].uniform_memory_ptr, &data, sizeof data);
+
+        err = vkBindBufferMemory(demo->device, demo->submission_resources[i].uniform_buffer,
+                                 demo->submission_resources[i].uniform_memory, 0);
+        assert(!err);
+    }
+}
+
+static void demo_prepare_descriptor_layout(struct demo *demo) {
+    const VkDescriptorSetLayoutBinding layout_bindings[2] = {
+        [0] =
+            {
+                .binding = 0,
+                .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+                .descriptorCount = 1,
+                .stageFlags = VK_SHADER_STAGE_VERTEX_BIT,
+                .pImmutableSamplers = NULL,
+            },
+        [1] =
+            {
+                .binding = 1,
+                .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+                .descriptorCount = DEMO_TEXTURE_COUNT,
+                .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
+                .pImmutableSamplers = NULL,
+            },
+    };
+    const VkDescriptorSetLayoutCreateInfo descriptor_layout = {
+        .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
+        .pNext = NULL,
+        .bindingCount = 2,
+        .pBindings = layout_bindings,
+    };
+    VkResult U_ASSERT_ONLY err;
+
+    err = vkCreateDescriptorSetLayout(demo->device, &descriptor_layout, NULL, &demo->desc_layout);
+    assert(!err);
+
+    const VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = {
+        .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
+        .pNext = NULL,
+        .setLayoutCount = 1,
+        .pSetLayouts = &demo->desc_layout,
+    };
+
+    err = vkCreatePipelineLayout(demo->device, &pPipelineLayoutCreateInfo, NULL, &demo->pipeline_layout);
+    assert(!err);
+}
+
+static void demo_prepare_render_pass(struct demo *demo) {
+    // The initial layout for the color and depth attachments will be LAYOUT_UNDEFINED
+    // because at the start of the renderpass, we don't care about their contents.
+    // At the start of the subpass, the color attachment's layout will be transitioned
+    // to LAYOUT_COLOR_ATTACHMENT_OPTIMAL and the depth stencil attachment's layout
+    // will be transitioned to LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL.  At the end of
+    // the renderpass, the color attachment's layout will be transitioned to
+    // LAYOUT_PRESENT_SRC_KHR to be ready to present.  This is all done as part of
+    // the renderpass, no barriers are necessary.
+    const VkAttachmentDescription attachments[2] = {
+        [0] =
+            {
+                .format = demo->format,
+                .flags = 0,
+                .samples = VK_SAMPLE_COUNT_1_BIT,
+                .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
+                .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
+                .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+                .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
+                .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
+                .finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
+            },
+        [1] =
+            {
+                .format = demo->depth.format,
+                .flags = 0,
+                .samples = VK_SAMPLE_COUNT_1_BIT,
+                .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
+                .storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
+                .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+                .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
+                .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
+                .finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+            },
+    };
+    const VkAttachmentReference color_reference = {
+        .attachment = 0,
+        .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+    };
+    const VkAttachmentReference depth_reference = {
+        .attachment = 1,
+        .layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+    };
+    const VkSubpassDescription subpass = {
+        .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
+        .flags = 0,
+        .inputAttachmentCount = 0,
+        .pInputAttachments = NULL,
+        .colorAttachmentCount = 1,
+        .pColorAttachments = &color_reference,
+        .pResolveAttachments = NULL,
+        .pDepthStencilAttachment = &depth_reference,
+        .preserveAttachmentCount = 0,
+        .pPreserveAttachments = NULL,
+    };
+
+    VkSubpassDependency attachmentDependencies[2] = {
+        [0] =
+            {
+                // Depth buffer is shared between swapchain images
+                .srcSubpass = VK_SUBPASS_EXTERNAL,
+                .dstSubpass = 0,
+                .srcStageMask = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
+                .dstStageMask = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
+                .srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
+                .dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
+                .dependencyFlags = 0,
+            },
+        [1] =
+            {
+                // Image Layout Transition
+                .srcSubpass = VK_SUBPASS_EXTERNAL,
+                .dstSubpass = 0,
+                .srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+                .dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+                .srcAccessMask = 0,
+                .dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
+                .dependencyFlags = 0,
+            },
+    };
+
+    const VkRenderPassCreateInfo rp_info = {
+        .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
+        .pNext = NULL,
+        .flags = 0,
+        .attachmentCount = 2,
+        .pAttachments = attachments,
+        .subpassCount = 1,
+        .pSubpasses = &subpass,
+        .dependencyCount = 2,
+        .pDependencies = attachmentDependencies,
+    };
+    VkResult U_ASSERT_ONLY err;
+
+    err = vkCreateRenderPass(demo->device, &rp_info, NULL, &demo->render_pass);
+    assert(!err);
+}
+
+static VkShaderModule demo_prepare_shader_module(const char *name, struct demo *demo, const uint32_t *code, size_t size) {
+    VkShaderModule module;
+    VkShaderModuleCreateInfo moduleCreateInfo;
+    VkResult U_ASSERT_ONLY err;
+
+    moduleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+    moduleCreateInfo.pNext = NULL;
+    moduleCreateInfo.flags = 0;
+    moduleCreateInfo.codeSize = size;
+    moduleCreateInfo.pCode = code;
+
+    err = vkCreateShaderModule(demo->device, &moduleCreateInfo, NULL, &module);
+    assert(!err);
+    demo_name_object(demo, VK_OBJECT_TYPE_SHADER_MODULE, (uint64_t)module, "%s", name);
+
+    return module;
+}
+
+static void demo_prepare_vs(struct demo *demo) {
+    const uint32_t vs_code[] = {
+#include "cube.vert.inc"
+    };
+    demo->vert_shader_module = demo_prepare_shader_module("cube.vert", demo, vs_code, sizeof(vs_code));
+}
+
+static void demo_prepare_fs(struct demo *demo) {
+    const uint32_t fs_code[] = {
+#include "cube.frag.inc"
+    };
+    demo->frag_shader_module = demo_prepare_shader_module("cube.frag", demo, fs_code, sizeof(fs_code));
+}
+
+static void demo_prepare_pipeline(struct demo *demo) {
+#define NUM_DYNAMIC_STATES 2 /*Viewport + Scissor*/
+
+    VkGraphicsPipelineCreateInfo pipeline;
+    VkPipelineCacheCreateInfo pipelineCache;
+    VkPipelineVertexInputStateCreateInfo vi;
+    VkPipelineInputAssemblyStateCreateInfo ia;
+    VkPipelineRasterizationStateCreateInfo rs;
+    VkPipelineColorBlendStateCreateInfo cb;
+    VkPipelineDepthStencilStateCreateInfo ds;
+    VkPipelineViewportStateCreateInfo vp;
+    VkPipelineMultisampleStateCreateInfo ms;
+    VkDynamicState dynamicStateEnables[NUM_DYNAMIC_STATES];
+    VkPipelineDynamicStateCreateInfo dynamicState;
+    VkResult U_ASSERT_ONLY err;
+
+    memset(dynamicStateEnables, 0, sizeof dynamicStateEnables);
+    memset(&dynamicState, 0, sizeof dynamicState);
+    dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
+    dynamicState.pDynamicStates = dynamicStateEnables;
+
+    memset(&pipeline, 0, sizeof(pipeline));
+    pipeline.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+    pipeline.layout = demo->pipeline_layout;
+
+    memset(&vi, 0, sizeof(vi));
+    vi.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
+
+    memset(&ia, 0, sizeof(ia));
+    ia.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
+    ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+
+    memset(&rs, 0, sizeof(rs));
+    rs.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
+    rs.polygonMode = VK_POLYGON_MODE_FILL;
+    rs.cullMode = VK_CULL_MODE_BACK_BIT;
+    rs.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
+    rs.depthClampEnable = VK_FALSE;
+    rs.rasterizerDiscardEnable = VK_FALSE;
+    rs.depthBiasEnable = VK_FALSE;
+    rs.lineWidth = 1.0f;
+
+    memset(&cb, 0, sizeof(cb));
+    cb.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
+    VkPipelineColorBlendAttachmentState att_state[1];
+    memset(att_state, 0, sizeof(att_state));
+    att_state[0].colorWriteMask = 0xf;
+    att_state[0].blendEnable = VK_FALSE;
+    cb.attachmentCount = 1;
+    cb.pAttachments = att_state;
+
+    memset(&vp, 0, sizeof(vp));
+    vp.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
+    vp.viewportCount = 1;
+    dynamicStateEnables[dynamicState.dynamicStateCount++] = VK_DYNAMIC_STATE_VIEWPORT;
+    vp.scissorCount = 1;
+    dynamicStateEnables[dynamicState.dynamicStateCount++] = VK_DYNAMIC_STATE_SCISSOR;
+
+    memset(&ds, 0, sizeof(ds));
+    ds.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
+    ds.depthTestEnable = VK_TRUE;
+    ds.depthWriteEnable = VK_TRUE;
+    ds.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL;
+    ds.depthBoundsTestEnable = VK_FALSE;
+    ds.back.failOp = VK_STENCIL_OP_KEEP;
+    ds.back.passOp = VK_STENCIL_OP_KEEP;
+    ds.back.compareOp = VK_COMPARE_OP_ALWAYS;
+    ds.stencilTestEnable = VK_FALSE;
+    ds.front = ds.back;
+
+    memset(&ms, 0, sizeof(ms));
+    ms.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
+    ms.pSampleMask = NULL;
+    ms.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
+
+    demo_prepare_vs(demo);
+    demo_prepare_fs(demo);
+
+    // Two stages: vs and fs
+    VkPipelineShaderStageCreateInfo shaderStages[2];
+    memset(&shaderStages, 0, 2 * sizeof(VkPipelineShaderStageCreateInfo));
+
+    shaderStages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+    shaderStages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
+    shaderStages[0].module = demo->vert_shader_module;
+    shaderStages[0].pName = "main";
+
+    shaderStages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+    shaderStages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
+    shaderStages[1].module = demo->frag_shader_module;
+    shaderStages[1].pName = "main";
+
+    memset(&pipelineCache, 0, sizeof(pipelineCache));
+    pipelineCache.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
+
+    err = vkCreatePipelineCache(demo->device, &pipelineCache, NULL, &demo->pipelineCache);
+    assert(!err);
+
+    pipeline.pVertexInputState = &vi;
+    pipeline.pInputAssemblyState = &ia;
+    pipeline.pRasterizationState = &rs;
+    pipeline.pColorBlendState = &cb;
+    pipeline.pMultisampleState = &ms;
+    pipeline.pViewportState = &vp;
+    pipeline.pDepthStencilState = &ds;
+    pipeline.stageCount = ARRAY_SIZE(shaderStages);
+    pipeline.pStages = shaderStages;
+    pipeline.renderPass = demo->render_pass;
+    pipeline.pDynamicState = &dynamicState;
+
+    err = vkCreateGraphicsPipelines(demo->device, demo->pipelineCache, 1, &pipeline, NULL, &demo->pipeline);
+    assert(!err);
+
+    vkDestroyShaderModule(demo->device, demo->frag_shader_module, NULL);
+    vkDestroyShaderModule(demo->device, demo->vert_shader_module, NULL);
+}
+
+static void demo_prepare_descriptor_pool(struct demo *demo) {
+    const VkDescriptorPoolSize type_counts[2] = {
+        [0] =
+            {
+                .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+                .descriptorCount = FRAME_LAG,
+            },
+        [1] =
+            {
+                .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+                .descriptorCount = FRAME_LAG * DEMO_TEXTURE_COUNT,
+            },
+    };
+    const VkDescriptorPoolCreateInfo descriptor_pool = {
+        .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
+        .pNext = NULL,
+        .maxSets = FRAME_LAG,
+        .poolSizeCount = 2,
+        .pPoolSizes = type_counts,
+    };
+    VkResult U_ASSERT_ONLY err;
+
+    err = vkCreateDescriptorPool(demo->device, &descriptor_pool, NULL, &demo->desc_pool);
+    assert(!err);
+}
+
+static void demo_prepare_descriptor_set(struct demo *demo) {
+    VkDescriptorImageInfo tex_descs[DEMO_TEXTURE_COUNT];
+    VkWriteDescriptorSet writes[2];
+    VkResult U_ASSERT_ONLY err;
+
+    VkDescriptorSetAllocateInfo alloc_info = {.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
+                                              .pNext = NULL,
+                                              .descriptorPool = demo->desc_pool,
+                                              .descriptorSetCount = 1,
+                                              .pSetLayouts = &demo->desc_layout};
+
+    VkDescriptorBufferInfo buffer_info;
+    buffer_info.offset = 0;
+    buffer_info.range = sizeof(struct vktexcube_vs_uniform);
+
+    memset(&tex_descs, 0, sizeof(tex_descs));
+    for (unsigned int i = 0; i < DEMO_TEXTURE_COUNT; i++) {
+        tex_descs[i].sampler = demo->textures[i].sampler;
+        tex_descs[i].imageView = demo->textures[i].view;
+        tex_descs[i].imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+    }
+
+    memset(&writes, 0, sizeof(writes));
+
+    writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+    writes[0].descriptorCount = 1;
+    writes[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+    writes[0].pBufferInfo = &buffer_info;
+
+    writes[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+    writes[1].dstBinding = 1;
+    writes[1].descriptorCount = DEMO_TEXTURE_COUNT;
+    writes[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+    writes[1].pImageInfo = tex_descs;
+
+    for (unsigned int i = 0; i < FRAME_LAG; i++) {
+        err = vkAllocateDescriptorSets(demo->device, &alloc_info, &demo->submission_resources[i].descriptor_set);
+        assert(!err);
+        buffer_info.buffer = demo->submission_resources[i].uniform_buffer;
+        writes[0].dstSet = demo->submission_resources[i].descriptor_set;
+        writes[1].dstSet = demo->submission_resources[i].descriptor_set;
+        vkUpdateDescriptorSets(demo->device, 2, writes, 0, NULL);
+    }
+}
+
+static void demo_prepare_framebuffers(struct demo *demo) {
+    VkImageView attachments[2];
+    attachments[1] = demo->depth.view;
+
+    const VkFramebufferCreateInfo fb_info = {
+        .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
+        .pNext = NULL,
+        .renderPass = demo->render_pass,
+        .attachmentCount = 2,
+        .pAttachments = attachments,
+        .width = demo->width,
+        .height = demo->height,
+        .layers = 1,
+    };
+    VkResult U_ASSERT_ONLY err;
+    uint32_t i;
+
+    for (i = 0; i < demo->swapchainImageCount; i++) {
+        attachments[0] = demo->swapchain_resources[i].view;
+        err = vkCreateFramebuffer(demo->device, &fb_info, NULL, &demo->swapchain_resources[i].framebuffer);
+        assert(!err);
+        demo_name_object(demo, VK_OBJECT_TYPE_FRAMEBUFFER, (uint64_t)demo->swapchain_resources[i].framebuffer, "Framebuffer(%u)",
+                         i);
+    }
+}
+
+static void demo_prepare_submission_sync_objects(struct demo *demo) {
+    VkSemaphoreCreateInfo semaphoreCreateInfo = {
+        .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
+        .pNext = NULL,
+        .flags = 0,
+    };
+    // Create fences that we can use to throttle if we get too far
+    // ahead of the image presents
+    VkFenceCreateInfo fence_ci = {
+        .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, .pNext = NULL, .flags = VK_FENCE_CREATE_SIGNALED_BIT};
+    VkResult U_ASSERT_ONLY err;
+    for (uint32_t i = 0; i < FRAME_LAG; i++) {
+        err = vkCreateFence(demo->device, &fence_ci, NULL, &demo->submission_resources[i].fence);
+        assert(!err);
+
+        err = vkCreateSemaphore(demo->device, &semaphoreCreateInfo, NULL, &demo->submission_resources[i].image_acquired_semaphore);
+        assert(!err);
+        demo_name_object(demo, VK_OBJECT_TYPE_SEMAPHORE, (uint64_t)demo->submission_resources[i].image_acquired_semaphore,
+                         "AcquireSem(%u)", i);
+    }
+}
+
+static void demo_prepare(struct demo *demo) {
+    VkResult U_ASSERT_ONLY err;
+    if (demo->cmd_pool == VK_NULL_HANDLE) {
+        const VkCommandPoolCreateInfo cmd_pool_info = {
+            .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
+            .pNext = NULL,
+            .queueFamilyIndex = demo->graphics_queue_family_index,
+            .flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
+        };
+        err = vkCreateCommandPool(demo->device, &cmd_pool_info, NULL, &demo->cmd_pool);
+        assert(!err);
+    }
+
+    const VkCommandBufferAllocateInfo cmd = {
+        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
+        .pNext = NULL,
+        .commandPool = demo->cmd_pool,
+        .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
+        .commandBufferCount = 1,
+    };
+    err = vkAllocateCommandBuffers(demo->device, &cmd, &demo->cmd);
+    assert(!err);
+    demo_name_object(demo, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)demo->cmd, "PrepareCB");
+    VkCommandBufferBeginInfo cmd_buf_info = {
+        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+        .pNext = NULL,
+        .flags = 0,
+        .pInheritanceInfo = NULL,
+    };
+    err = vkBeginCommandBuffer(demo->cmd, &cmd_buf_info);
+    demo_push_cb_label(demo, demo->cmd, NULL, "Prepare");
+    assert(!err);
+
+    demo_prepare_textures(demo);
+    demo_prepare_cube_data_buffers(demo);
+
+    demo_prepare_descriptor_layout(demo);
+
+    // Only need to know the format of the depth buffer before we create the renderpass
+    demo->depth.format = VK_FORMAT_D16_UNORM;
+    demo_prepare_render_pass(demo);
+    demo_prepare_pipeline(demo);
+
+    for (uint32_t i = 0; i < FRAME_LAG; i++) {
+        err = vkAllocateCommandBuffers(demo->device, &cmd, &demo->submission_resources[i].cmd);
+        assert(!err);
+        demo_name_object(demo, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)demo->submission_resources[i].cmd, "MainCommandBuffer(%u)",
+                         i);
+    }
+
+    if (demo->separate_present_queue) {
+        const VkCommandPoolCreateInfo present_cmd_pool_info = {
+            .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
+            .pNext = NULL,
+            .queueFamilyIndex = demo->present_queue_family_index,
+            .flags = 0,
+        };
+        err = vkCreateCommandPool(demo->device, &present_cmd_pool_info, NULL, &demo->present_cmd_pool);
+        assert(!err);
+        const VkCommandBufferAllocateInfo present_cmd_info = {
+            .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
+            .pNext = NULL,
+            .commandPool = demo->present_cmd_pool,
+            .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
+            .commandBufferCount = 1,
+        };
+        for (uint32_t i = 0; i < FRAME_LAG; i++) {
+            err = vkAllocateCommandBuffers(demo->device, &present_cmd_info, &demo->submission_resources[i].graphics_to_present_cmd);
+            assert(!err);
+            demo_name_object(demo, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)demo->submission_resources[i].graphics_to_present_cmd,
+                             "GfxToPresent(%u)", i);
+        }
+    }
+
+    demo_prepare_descriptor_pool(demo);
+    demo_prepare_descriptor_set(demo);
+
+    demo_prepare_submission_sync_objects(demo);
+
+    /*
+     * Prepare functions above may generate pipeline commands
+     * that need to be flushed before beginning the render loop.
+     */
+    demo_pop_cb_label(demo, demo->cmd);  // "Prepare"
+    demo_flush_init_cmd(demo);
+    if (demo->staging_texture.buffer) {
+        demo_destroy_texture(demo, &demo->staging_texture);
+    }
+    demo->current_submission_index = 0;
+    demo->initialized = true;
+    demo_prepare_swapchain(demo);
+}
+
+static void demo_cleanup(struct demo *demo) {
+    uint32_t i;
+
+    demo->initialized = false;
+    vkDeviceWaitIdle(demo->device);
+
+    // Wait for fences from present operations
+    for (i = 0; i < FRAME_LAG; i++) {
+        vkWaitForFences(demo->device, 1, &demo->submission_resources[i].fence, VK_TRUE, UINT64_MAX);
+    }
+
+    // If the window is currently minimized, demo_resize has already done some cleanup for us.
+    if (!demo->is_minimized) {
+        vkDestroyDescriptorPool(demo->device, demo->desc_pool, NULL);
+
+        vkDestroyPipeline(demo->device, demo->pipeline, NULL);
+        vkDestroyPipelineCache(demo->device, demo->pipelineCache, NULL);
+        vkDestroyRenderPass(demo->device, demo->render_pass, NULL);
+        vkDestroyPipelineLayout(demo->device, demo->pipeline_layout, NULL);
+        vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout, NULL);
+
+        for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
+            vkDestroyImageView(demo->device, demo->textures[i].view, NULL);
+            vkDestroyImage(demo->device, demo->textures[i].image, NULL);
+            vkFreeMemory(demo->device, demo->textures[i].mem, NULL);
+            vkDestroySampler(demo->device, demo->textures[i].sampler, NULL);
+        }
+        vkDestroySwapchainKHR(demo->device, demo->swapchain, NULL);
+
+        vkDestroyImageView(demo->device, demo->depth.view, NULL);
+        vkDestroyImage(demo->device, demo->depth.image, NULL);
+        vkFreeMemory(demo->device, demo->depth.mem, NULL);
+
+        for (i = 0; i < demo->swapchainImageCount; i++) {
+            vkDestroyImageView(demo->device, demo->swapchain_resources[i].view, NULL);
+            vkDestroyFramebuffer(demo->device, demo->swapchain_resources[i].framebuffer, NULL);
+            vkDestroySemaphore(demo->device, demo->swapchain_resources[i].draw_complete_semaphore, NULL);
+            if (demo->separate_present_queue) {
+                vkDestroySemaphore(demo->device, demo->swapchain_resources[i].image_ownership_semaphore, NULL);
+            }
+        }
+
+        for (i = 0; i < FRAME_LAG; i++) {
+            vkDestroyFence(demo->device, demo->submission_resources[i].fence, NULL);
+            vkDestroySemaphore(demo->device, demo->submission_resources[i].image_acquired_semaphore, NULL);
+            vkDestroyBuffer(demo->device, demo->submission_resources[i].uniform_buffer, NULL);
+            vkUnmapMemory(demo->device, demo->submission_resources[i].uniform_memory);
+            vkFreeMemory(demo->device, demo->submission_resources[i].uniform_memory, NULL);
+        }
+        free(demo->queue_props);
+        vkDestroyCommandPool(demo->device, demo->cmd_pool, NULL);
+
+        if (demo->separate_present_queue) {
+            vkDestroyCommandPool(demo->device, demo->present_cmd_pool, NULL);
+        }
+    }
+    vkDeviceWaitIdle(demo->device);
+    vkDestroyDevice(demo->device, NULL);
+    if (demo->validate) {
+        vkDestroyDebugUtilsMessengerEXT(demo->inst, demo->dbg_messenger, NULL);
+    }
+    vkDestroySurfaceKHR(demo->inst, demo->surface, NULL);
+
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+    if (demo->wsi_platform == WSI_PLATFORM_XLIB) {
+        XDestroyWindow(demo->xlib_display, demo->xlib_window);
+        XCloseDisplay(demo->xlib_display);
+    }
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+    if (demo->wsi_platform == WSI_PLATFORM_XCB) {
+        xcb_destroy_window(demo->connection, demo->xcb_window);
+        xcb_disconnect(demo->connection);
+        free(demo->atom_wm_delete_window);
+    }
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+    if (demo->wsi_platform == WSI_PLATFORM_WAYLAND) {
+        if (demo->keyboard) wl_keyboard_destroy(demo->keyboard);
+        if (demo->pointer) wl_pointer_destroy(demo->pointer);
+        if (demo->seat) wl_seat_destroy(demo->seat);
+        xdg_toplevel_destroy(demo->xdg_toplevel);
+        xdg_surface_destroy(demo->xdg_surface);
+        wl_surface_destroy(demo->window);
+        xdg_wm_base_destroy(demo->xdg_wm_base);
+        if (demo->xdg_decoration_mgr) {
+            zxdg_toplevel_decoration_v1_destroy(demo->toplevel_decoration);
+            zxdg_decoration_manager_v1_destroy(demo->xdg_decoration_mgr);
+        }
+        wl_compositor_destroy(demo->compositor);
+        wl_registry_destroy(demo->registry);
+        wl_display_disconnect(demo->wayland_display);
+    }
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+    if (demo->wsi_platform == WSI_PLATFORM_DIRECTFB) {
+        demo->event_buffer->Release(demo->event_buffer);
+        demo->directfb_window->Release(demo->directfb_window);
+        demo->dfb->Release(demo->dfb);
+    }
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+    if (demo->wsi_platform == WSI_PLATFORM_QNX) {
+        screen_destroy_event(demo->screen_event);
+        screen_destroy_window(demo->screen_window);
+        screen_destroy_context(demo->screen_context);
+    }
+#endif
+
+    vkDestroyInstance(demo->inst, NULL);
+    unload_vulkan_library();
+}
+
+static void demo_resize(struct demo *demo) {
+    uint32_t i;
+
+    // Don't react to resize until after first initialization.
+    if (!demo->initialized) {
+        return;
+    }
+
+    // Don't do anything if the surface has zero size, as vulkan disallows creating swapchains with zero area
+    // We use is_minimized to track this because zero size window usually occurs from minimizing
+    if (demo->width == 0 || demo->height == 0) {
+        demo->is_minimized = true;
+        return;
+    } else {
+        demo->is_minimized = false;
+    }
+
+    // In order to properly resize the window, we must re-create the
+    // swapchain
+    //
+    // First, destroy the old swapchain and its associated resources, setting swapchain_ready to false to prevent draw from running
+
+    if (demo->swapchain_ready) {
+        demo->swapchain_ready = false;
+        vkDeviceWaitIdle(demo->device);
+
+        vkDestroyImageView(demo->device, demo->depth.view, NULL);
+        vkDestroyImage(demo->device, demo->depth.image, NULL);
+        vkFreeMemory(demo->device, demo->depth.mem, NULL);
+        memset(&(demo->depth), 0, sizeof(demo->depth));
+
+        for (i = 0; i < demo->swapchainImageCount; i++) {
+            vkDestroyImageView(demo->device, demo->swapchain_resources[i].view, NULL);
+            vkDestroyFramebuffer(demo->device, demo->swapchain_resources[i].framebuffer, NULL);
+            vkDestroySemaphore(demo->device, demo->swapchain_resources[i].draw_complete_semaphore, NULL);
+            if (demo->separate_present_queue) {
+                vkDestroySemaphore(demo->device, demo->swapchain_resources[i].image_ownership_semaphore, NULL);
+            }
+        }
+        memset(&(demo->swapchain_resources), 0, sizeof(SwapchainImageResources) * MAX_SWAPCHAIN_IMAGE_COUNT);
+    }
+
+    // Second, recreate the swapchain, depth buffer, and framebuffers.
+    demo_prepare_swapchain(demo);
+}
+
+// On MS-Windows, make this a global, so it's available to WndProc()
+struct demo demo;
+
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+static void demo_run(struct demo *demo) {
+    if (!demo->initialized || !demo->swapchain_ready) return;
+
+    demo_draw(demo);
+    if (!demo->is_minimized) {
+        demo->curFrame++;
+    }
+    if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) {
+        PostQuitMessage(validation_error);
+    }
+}
+
+// MS-Windows event handling function:
+LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
+    switch (uMsg) {
+        case WM_CLOSE:
+            PostQuitMessage(validation_error);
+            break;
+        case WM_PAINT:
+            // The validation callback calls MessageBox which can generate paint
+            // events - don't make more Vulkan calls if we got here from the
+            // callback
+            if (!in_callback) {
+                demo_run(&demo);
+            }
+            break;
+        case WM_GETMINMAXINFO:  // set window's minimum size
+            ((MINMAXINFO *)lParam)->ptMinTrackSize = demo.minsize;
+            return 0;
+        case WM_ERASEBKGND:
+            return 1;
+        case WM_SIZE:
+            // Resize the application to the new window size, except when
+            // it was minimized. Vulkan doesn't support images or swapchains
+            // with width=0 and height=0.
+            if (wParam != SIZE_MINIMIZED) {
+                demo.width = lParam & 0xffff;
+                demo.height = (lParam & 0xffff0000) >> 16;
+                demo_resize(&demo);
+            }
+            break;
+        case WM_KEYDOWN:
+            switch (wParam) {
+                case VK_ESCAPE:
+                    PostQuitMessage(validation_error);
+                    break;
+                case VK_LEFT:
+                    demo.spin_angle -= demo.spin_increment;
+                    break;
+                case VK_RIGHT:
+                    demo.spin_angle += demo.spin_increment;
+                    break;
+                case VK_SPACE:
+                    demo.pause = !demo.pause;
+                    break;
+            }
+            return 0;
+        default:
+            break;
+    }
+    return (DefWindowProc(hWnd, uMsg, wParam, lParam));
+}
+
+static void demo_create_window(struct demo *demo) {
+    WNDCLASSEX win_class;
+
+    // Initialize the window class structure:
+    win_class.cbSize = sizeof(WNDCLASSEX);
+    win_class.style = CS_HREDRAW | CS_VREDRAW;
+    win_class.lpfnWndProc = WndProc;
+    win_class.cbClsExtra = 0;
+    win_class.cbWndExtra = 0;
+    win_class.hInstance = demo->connection;  // hInstance
+    win_class.hIcon = LoadIcon(NULL, IDI_APPLICATION);
+    win_class.hCursor = LoadCursor(NULL, IDC_ARROW);
+    win_class.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
+    win_class.lpszMenuName = NULL;
+    win_class.lpszClassName = demo->name;
+    win_class.hIconSm = LoadIcon(NULL, IDI_WINLOGO);
+    // Register window class:
+    if (!RegisterClassEx(&win_class)) {
+        // It didn't work, so try to give a useful error:
+        printf("Unexpected error trying to start the application!\n");
+        fflush(stdout);
+        exit(1);
+    }
+    // Create window with the registered class:
+    RECT wr = {0, 0, demo->width, demo->height};
+    AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);
+    demo->window = CreateWindowEx(0,
+                                  demo->name,            // class name
+                                  demo->name,            // app name
+                                  WS_OVERLAPPEDWINDOW |  // window style
+                                      WS_VISIBLE | WS_SYSMENU,
+                                  100, 100,            // x/y coords
+                                  wr.right - wr.left,  // width
+                                  wr.bottom - wr.top,  // height
+                                  NULL,                // handle to parent
+                                  NULL,                // handle to menu
+                                  demo->connection,    // hInstance
+                                  NULL);               // no extra parameters
+    if (!demo->window) {
+        // It didn't work, so try to give a useful error:
+        printf("Cannot create a window in which to draw!\n");
+        fflush(stdout);
+        exit(1);
+    }
+    // Window client area size must be at least 1 pixel high, to prevent crash.
+    demo->minsize.x = GetSystemMetrics(SM_CXMINTRACK);
+    demo->minsize.y = GetSystemMetrics(SM_CYMINTRACK) + 1;
+}
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+static void demo_create_xlib_window(struct demo *demo) {
+    const char *display_envar = getenv("DISPLAY");
+    if (display_envar == NULL || display_envar[0] == '\0') {
+        printf("Environment variable DISPLAY requires a valid value.\nExiting ...\n");
+        fflush(stdout);
+        exit(1);
+    }
+
+    XInitThreads();
+    demo->xlib_display = XOpenDisplay(NULL);
+    long visualMask = VisualScreenMask;
+    int numberOfVisuals;
+    XVisualInfo vInfoTemplate = {};
+    vInfoTemplate.screen = DefaultScreen(demo->xlib_display);
+    XVisualInfo *visualInfo = XGetVisualInfo(demo->xlib_display, visualMask, &vInfoTemplate, &numberOfVisuals);
+
+    Colormap colormap =
+        XCreateColormap(demo->xlib_display, RootWindow(demo->xlib_display, vInfoTemplate.screen), visualInfo->visual, AllocNone);
+
+    XSetWindowAttributes windowAttributes = {};
+    windowAttributes.colormap = colormap;
+    windowAttributes.background_pixel = 0xFFFFFFFF;
+    windowAttributes.border_pixel = 0;
+    windowAttributes.event_mask = KeyPressMask | KeyReleaseMask | StructureNotifyMask | ExposureMask;
+
+    demo->xlib_window = XCreateWindow(demo->xlib_display, RootWindow(demo->xlib_display, vInfoTemplate.screen), 0, 0, demo->width,
+                                      demo->height, 0, visualInfo->depth, InputOutput, visualInfo->visual,
+                                      CWBackPixel | CWBorderPixel | CWEventMask | CWColormap, &windowAttributes);
+
+    XSelectInput(demo->xlib_display, demo->xlib_window, ExposureMask | KeyPressMask);
+    XMapWindow(demo->xlib_display, demo->xlib_window);
+    XFlush(demo->xlib_display);
+    demo->xlib_wm_delete_window = XInternAtom(demo->xlib_display, "WM_DELETE_WINDOW", False);
+    XSetWMProtocols(demo->xlib_display, demo->xlib_window, &demo->xlib_wm_delete_window, 1);
+}
+static void demo_handle_xlib_event(struct demo *demo, const XEvent *event) {
+    switch (event->type) {
+        case ClientMessage:
+            if ((Atom)event->xclient.data.l[0] == demo->xlib_wm_delete_window) demo->quit = true;
+            break;
+        case KeyPress:
+            switch (event->xkey.keycode) {
+                case 0x9:  // Escape
+                    demo->quit = true;
+                    break;
+                case 0x71:  // left arrow key
+                    demo->spin_angle -= demo->spin_increment;
+                    break;
+                case 0x72:  // right arrow key
+                    demo->spin_angle += demo->spin_increment;
+                    break;
+                case 0x41:  // space bar
+                    demo->pause = !demo->pause;
+                    break;
+            }
+            break;
+        case ConfigureNotify:
+            if ((demo->width != event->xconfigure.width) || (demo->height != event->xconfigure.height)) {
+                demo->width = event->xconfigure.width;
+                demo->height = event->xconfigure.height;
+                demo_resize(demo);
+            }
+            break;
+        default:
+            break;
+    }
+}
+
+static void demo_run_xlib(struct demo *demo) {
+    while (!demo->quit) {
+        XEvent event;
+
+        if (demo->pause) {
+            XNextEvent(demo->xlib_display, &event);
+            demo_handle_xlib_event(demo, &event);
+        }
+        while (XPending(demo->xlib_display) > 0) {
+            XNextEvent(demo->xlib_display, &event);
+            demo_handle_xlib_event(demo, &event);
+        }
+        if (demo->initialized && demo->swapchain_ready) {
+            demo_draw(demo);
+            if (!demo->is_minimized) {
+                demo->curFrame++;
+            }
+            if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) demo->quit = true;
+        }
+    }
+}
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+static void demo_handle_xcb_event(struct demo *demo, const xcb_generic_event_t *event) {
+    uint8_t event_code = event->response_type & 0x7f;
+    switch (event_code) {
+        case XCB_EXPOSE:
+            // TODO: Resize window
+            break;
+        case XCB_CLIENT_MESSAGE:
+            if ((*(xcb_client_message_event_t *)event).data.data32[0] == (*demo->atom_wm_delete_window).atom) {
+                demo->quit = true;
+            }
+            break;
+        case XCB_KEY_RELEASE: {
+            const xcb_key_release_event_t *key = (const xcb_key_release_event_t *)event;
+
+            switch (key->detail) {
+                case 0x9:  // Escape
+                    demo->quit = true;
+                    break;
+                case 0x71:  // left arrow key
+                    demo->spin_angle -= demo->spin_increment;
+                    break;
+                case 0x72:  // right arrow key
+                    demo->spin_angle += demo->spin_increment;
+                    break;
+                case 0x41:  // space bar
+                    demo->pause = !demo->pause;
+                    break;
+            }
+        } break;
+        case XCB_CONFIGURE_NOTIFY: {
+            const xcb_configure_notify_event_t *cfg = (const xcb_configure_notify_event_t *)event;
+            if ((demo->width != cfg->width) || (demo->height != cfg->height)) {
+                demo->width = cfg->width;
+                demo->height = cfg->height;
+                demo_resize(demo);
+            }
+        } break;
+        default:
+            break;
+    }
+}
+
+static void demo_run_xcb(struct demo *demo) {
+    xcb_flush(demo->connection);
+
+    while (!demo->quit) {
+        xcb_generic_event_t *event;
+
+        if (demo->pause) {
+            event = xcb_wait_for_event(demo->connection);
+        } else {
+            event = xcb_poll_for_event(demo->connection);
+        }
+        while (event) {
+            demo_handle_xcb_event(demo, event);
+            free(event);
+            event = xcb_poll_for_event(demo->connection);
+        }
+        if (demo->initialized && demo->swapchain_ready) {
+            demo_draw(demo);
+            if (!demo->is_minimized) {
+                demo->curFrame++;
+            }
+            if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) demo->quit = true;
+        }
+    }
+}
+
+static void demo_create_xcb_window(struct demo *demo) {
+    uint32_t value_mask, value_list[32];
+
+    demo->xcb_window = xcb_generate_id(demo->connection);
+
+    value_mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
+    value_list[0] = demo->screen->black_pixel;
+    value_list[1] = XCB_EVENT_MASK_KEY_RELEASE | XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_STRUCTURE_NOTIFY;
+
+    xcb_create_window(demo->connection, XCB_COPY_FROM_PARENT, demo->xcb_window, demo->screen->root, 0, 0, demo->width, demo->height,
+                      0, XCB_WINDOW_CLASS_INPUT_OUTPUT, demo->screen->root_visual, value_mask, value_list);
+
+    char *name = "Vkcube X11";
+    xcb_intern_atom_cookie_t net_wm_name_cookie = xcb_intern_atom(demo->connection, 0, strlen("_NET_WM_NAME"), "_NET_WM_NAME");
+    xcb_intern_atom_cookie_t utf8_string_cookie = xcb_intern_atom(demo->connection, 0, strlen("UTF8_STRING"), "UTF8_STRING");
+    xcb_intern_atom_reply_t *net_wm_name_reply = xcb_intern_atom_reply(demo->connection, net_wm_name_cookie, NULL);
+    xcb_intern_atom_reply_t *utf8_string_reply = xcb_intern_atom_reply(demo->connection, utf8_string_cookie, NULL);
+    xcb_change_property(demo->connection, XCB_PROP_MODE_REPLACE,
+                        demo->xcb_window, net_wm_name_reply->atom,
+                        utf8_string_reply->atom, 8, strlen(name), name);
+
+    /* Magic code that will send notification when window is destroyed */
+    xcb_intern_atom_cookie_t cookie = xcb_intern_atom(demo->connection, 1, 12, "WM_PROTOCOLS");
+    xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(demo->connection, cookie, 0);
+
+    xcb_intern_atom_cookie_t cookie2 = xcb_intern_atom(demo->connection, 0, 16, "WM_DELETE_WINDOW");
+    demo->atom_wm_delete_window = xcb_intern_atom_reply(demo->connection, cookie2, 0);
+
+    xcb_change_property(demo->connection, XCB_PROP_MODE_REPLACE, demo->xcb_window, (*reply).atom, 4, 32, 1,
+                        &(*demo->atom_wm_delete_window).atom);
+    free(reply);
+
+    xcb_map_window(demo->connection, demo->xcb_window);
+
+    // Force the x/y coordinates to 100,100 results are identical in consecutive
+    // runs
+    const uint32_t coords[] = {100, 100};
+    xcb_configure_window(demo->connection, demo->xcb_window, XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y, coords);
+}
+// VK_USE_PLATFORM_XCB_KHR
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+static void demo_run(struct demo *demo) {
+    while (!demo->quit) {
+        // Flush any commands to the server
+        wl_display_flush(demo->wayland_display);
+
+        if (demo->pause) {
+            // block and wait for input
+            wl_display_dispatch(demo->wayland_display);
+        } else {
+            // Lock the display event queue in case the driver is doing something on another thread
+            // while we wait, keep pumping events
+            while (wl_display_prepare_read(demo->wayland_display) != 0) {
+                wl_display_dispatch_pending(demo->wayland_display);
+            }
+            // Actually do the read from the socket
+            wl_display_read_events(demo->wayland_display);
+
+            // Pump events
+            wl_display_dispatch_pending(demo->wayland_display);
+            if (demo->initialized && demo->swapchain_ready) {
+                demo_draw(demo);
+                if (!demo->is_minimized) {
+                    demo->curFrame++;
+                }
+                if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) demo->quit = true;
+            }
+        }
+    }
+}
+
+static void handle_surface_configure(void *data, struct xdg_surface *xdg_surface, uint32_t serial) {
+    struct demo *demo = (struct demo *)data;
+    xdg_surface_ack_configure(xdg_surface, serial);
+    demo->xdg_surface_has_been_configured = 1;
+    if (demo->pending_width > 0) {
+        demo->width = demo->pending_width;
+    }
+    if (demo->pending_height > 0) {
+        demo->height = demo->pending_height;
+    }
+    demo_resize(demo);
+}
+
+static const struct xdg_surface_listener xdg_surface_listener = {handle_surface_configure};
+
+static void handle_toplevel_configure(void *data, struct xdg_toplevel *xdg_toplevel UNUSED, int32_t width, int32_t height,
+                                      struct wl_array *states UNUSED) {
+    struct demo *demo = (struct demo *)data;
+    /* zero values imply the program may choose its own size, so in that case
+     * stay with the existing value (which on startup is the default) */
+    if (width > 0) {
+        demo->pending_width = width;
+    }
+    if (height > 0) {
+        demo->pending_height = height;
+    }
+    /* This should be followed by a surface configure */
+}
+
+static void handle_toplevel_close(void *data, struct xdg_toplevel *xdg_toplevel UNUSED) {
+    struct demo *demo = (struct demo *)data;
+    demo->quit = true;
+}
+
+static const struct xdg_toplevel_listener xdg_toplevel_listener = {handle_toplevel_configure, handle_toplevel_close};
+
+static void demo_create_wayland_window(struct demo *demo) {
+    if (!demo->xdg_wm_base) {
+        printf("Compositor did not provide the standard protocol xdg-wm-base\n");
+        fflush(stdout);
+        exit(1);
+    }
+
+    demo->window = wl_compositor_create_surface(demo->compositor);
+    if (!demo->window) {
+        printf("Can not create wayland_surface from compositor!\n");
+        fflush(stdout);
+        exit(1);
+    }
+
+    demo->xdg_surface = xdg_wm_base_get_xdg_surface(demo->xdg_wm_base, demo->window);
+    if (!demo->xdg_surface) {
+        printf("Can not get xdg_surface from wayland_surface!\n");
+        fflush(stdout);
+        exit(1);
+    }
+    demo->xdg_toplevel = xdg_surface_get_toplevel(demo->xdg_surface);
+    if (!demo->xdg_toplevel) {
+        printf("Can not allocate xdg_toplevel for xdg_surface!\n");
+        fflush(stdout);
+        exit(1);
+    }
+    xdg_surface_add_listener(demo->xdg_surface, &xdg_surface_listener, demo);
+    xdg_toplevel_add_listener(demo->xdg_toplevel, &xdg_toplevel_listener, demo);
+    xdg_toplevel_set_title(demo->xdg_toplevel, APP_SHORT_NAME);
+    if (demo->xdg_decoration_mgr) {
+        // if supported, let the compositor render titlebars for us
+        demo->toplevel_decoration =
+            zxdg_decoration_manager_v1_get_toplevel_decoration(demo->xdg_decoration_mgr, demo->xdg_toplevel);
+        zxdg_toplevel_decoration_v1_set_mode(demo->toplevel_decoration, ZXDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE);
+    }
+
+    wl_surface_commit(demo->window);
+}
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+static void demo_create_directfb_window(struct demo *demo) {
+    DFBResult ret;
+
+    ret = DirectFBInit(NULL, NULL);
+    if (ret) {
+        printf("DirectFBInit failed to initialize DirectFB!\n");
+        fflush(stdout);
+        exit(1);
+    }
+
+    ret = DirectFBCreate(&demo->dfb);
+    if (ret) {
+        printf("DirectFBCreate failed to create main interface of DirectFB!\n");
+        fflush(stdout);
+        exit(1);
+    }
+
+    DFBSurfaceDescription desc;
+    desc.flags = DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT;
+    desc.caps = DSCAPS_PRIMARY;
+    desc.width = demo->width;
+    desc.height = demo->height;
+    ret = demo->dfb->CreateSurface(demo->dfb, &desc, &demo->directfb_window);
+    if (ret) {
+        printf("CreateSurface failed to create DirectFB surface interface!\n");
+        fflush(stdout);
+        exit(1);
+    }
+
+    ret = demo->dfb->CreateInputEventBuffer(demo->dfb, DICAPS_KEYS, DFB_FALSE, &demo->event_buffer);
+    if (ret) {
+        printf("CreateInputEventBuffer failed to create DirectFB event buffer interface!\n");
+        fflush(stdout);
+        exit(1);
+    }
+}
+
+static void demo_handle_directfb_event(struct demo *demo, const DFBInputEvent *event) {
+    if (event->type != DIET_KEYPRESS) return;
+    switch (event->key_symbol) {
+        case DIKS_ESCAPE:  // Escape
+            demo->quit = true;
+            break;
+        case DIKS_CURSOR_LEFT:  // left arrow key
+            demo->spin_angle -= demo->spin_increment;
+            break;
+        case DIKS_CURSOR_RIGHT:  // right arrow key
+            demo->spin_angle += demo->spin_increment;
+            break;
+        case DIKS_SPACE:  // space bar
+            demo->pause = !demo->pause;
+            break;
+        default:
+            break;
+    }
+}
+
+static void demo_run_directfb(struct demo *demo) {
+    while (!demo->quit) {
+        DFBInputEvent event;
+
+        if (demo->pause) {
+            demo->event_buffer->WaitForEvent(demo->event_buffer);
+            if (!demo->event_buffer->GetEvent(demo->event_buffer, DFB_EVENT(&event))) demo_handle_directfb_event(demo, &event);
+        } else {
+            if (!demo->event_buffer->GetEvent(demo->event_buffer, DFB_EVENT(&event))) demo_handle_directfb_event(demo, &event);
+            if (demo->initialized && demo->swapchain_ready) {
+                demo_draw(demo);
+                if (!demo->is_minimized) {
+                    demo->curFrame++;
+                }
+                if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) demo->quit = true;
+            }
+        }
+    }
+}
+#endif
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+static void demo_run(struct demo *demo) {
+    if (!demo->initialized || !demo->swapchain_ready) return;
+
+    demo_draw(demo);
+    if (!demo->is_minimized) {
+        demo->curFrame++;
+    }
+}
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+static void demo_run(struct demo *demo) {
+    if (!demo->initialized || !demo->swapchain_ready) return;
+
+    demo_draw(demo);
+    if (!demo->is_minimized) {
+        demo->curFrame++;
+    }
+    if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) {
+        demo->quit = TRUE;
+    }
+}
+#endif
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+static VkResult demo_create_display_surface(struct demo *demo) {
+    VkResult U_ASSERT_ONLY err;
+    uint32_t display_count;
+    uint32_t mode_count;
+    uint32_t plane_count;
+    VkDisplayPropertiesKHR display_props;
+    VkDisplayKHR display;
+    VkDisplayModePropertiesKHR mode_props;
+    VkDisplayPlanePropertiesKHR *plane_props;
+    VkBool32 found_plane = VK_FALSE;
+    uint32_t plane_index;
+    VkExtent2D image_extent;
+    VkDisplaySurfaceCreateInfoKHR create_info;
+
+    // Get the first display
+    display_count = 1;
+    err = vkGetPhysicalDeviceDisplayPropertiesKHR(demo->gpu, &display_count, &display_props);
+    assert(!err || (err == VK_INCOMPLETE));
+
+    display = display_props.display;
+
+    // Get the first mode of the display
+    err = vkGetDisplayModePropertiesKHR(demo->gpu, display, &mode_count, NULL);
+    assert(!err);
+
+    if (mode_count == 0) {
+        printf("Cannot find any mode for the display!\n");
+        fflush(stdout);
+        exit(1);
+    }
+
+    mode_count = 1;
+    err = vkGetDisplayModePropertiesKHR(demo->gpu, display, &mode_count, &mode_props);
+    assert(!err || (err == VK_INCOMPLETE));
+
+    // Get the list of planes
+    err = vkGetPhysicalDeviceDisplayPlanePropertiesKHR(demo->gpu, &plane_count, NULL);
+    assert(!err);
+
+    if (plane_count == 0) {
+        printf("Cannot find any plane!\n");
+        fflush(stdout);
+        exit(1);
+    }
+
+    plane_props = malloc(sizeof(VkDisplayPlanePropertiesKHR) * plane_count);
+    assert(plane_props);
+
+    err = vkGetPhysicalDeviceDisplayPlanePropertiesKHR(demo->gpu, &plane_count, plane_props);
+    assert(!err);
+
+    // Find a plane compatible with the display
+    for (plane_index = 0; plane_index < plane_count; plane_index++) {
+        uint32_t supported_count;
+        VkDisplayKHR *supported_displays;
+
+        // Disqualify planes that are bound to a different display
+        if ((plane_props[plane_index].currentDisplay != VK_NULL_HANDLE) && (plane_props[plane_index].currentDisplay != display)) {
+            continue;
+        }
+
+        err = vkGetDisplayPlaneSupportedDisplaysKHR(demo->gpu, plane_index, &supported_count, NULL);
+        assert(!err);
+
+        if (supported_count == 0) {
+            continue;
+        }
+
+        supported_displays = malloc(sizeof(VkDisplayKHR) * supported_count);
+        assert(supported_displays);
+
+        err = vkGetDisplayPlaneSupportedDisplaysKHR(demo->gpu, plane_index, &supported_count, supported_displays);
+        assert(!err);
+
+        for (uint32_t i = 0; i < supported_count; i++) {
+            if (supported_displays[i] == display) {
+                found_plane = VK_TRUE;
+                break;
+            }
+        }
+
+        free(supported_displays);
+
+        if (found_plane) {
+            break;
+        }
+    }
+
+    if (!found_plane) {
+        printf("Cannot find a plane compatible with the display!\n");
+        fflush(stdout);
+        exit(1);
+    }
+
+    VkDisplayPlaneCapabilitiesKHR planeCaps;
+    vkGetDisplayPlaneCapabilitiesKHR(demo->gpu, mode_props.displayMode, plane_index, &planeCaps);
+    // Find a supported alpha mode
+    VkDisplayPlaneAlphaFlagBitsKHR alphaMode = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR;
+    VkDisplayPlaneAlphaFlagBitsKHR alphaModes[4] = {
+        VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR,
+        VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR,
+        VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR,
+        VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR,
+    };
+    for (uint32_t i = 0; i < sizeof(alphaModes); i++) {
+        if (planeCaps.supportedAlpha & alphaModes[i]) {
+            alphaMode = alphaModes[i];
+            break;
+        }
+    }
+    image_extent.width = mode_props.parameters.visibleRegion.width;
+    image_extent.height = mode_props.parameters.visibleRegion.height;
+
+    create_info.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
+    create_info.pNext = NULL;
+    create_info.flags = 0;
+    create_info.displayMode = mode_props.displayMode;
+    create_info.planeIndex = plane_index;
+    create_info.planeStackIndex = plane_props[plane_index].currentStackIndex;
+    create_info.transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
+    create_info.alphaMode = alphaMode;
+    create_info.globalAlpha = 1.0f;
+    create_info.imageExtent = image_extent;
+
+    free(plane_props);
+
+    return vkCreateDisplayPlaneSurfaceKHR(demo->inst, &create_info, NULL, &demo->surface);
+}
+
+static void demo_run_display(struct demo *demo) {
+    while (!demo->quit) {
+        demo_draw(demo);
+        demo->curFrame++;
+
+        if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) {
+            demo->quit = true;
+        }
+    }
+}
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+
+#include <sys/keycodes.h>
+
+static void demo_run(struct demo *demo) {
+    int size[2] = {0, 0};
+    screen_window_t win;
+    int val;
+    int rc;
+
+    while (!demo->quit) {
+        while (!screen_get_event(demo->screen_context, demo->screen_event, demo->pause ? ~0 : 0)) {
+            rc = screen_get_event_property_iv(demo->screen_event, SCREEN_PROPERTY_TYPE, &val);
+            if (rc) {
+                printf("Cannot get SCREEN_PROPERTY_TYPE of the event! (%s)\n", strerror(errno));
+                fflush(stdout);
+                demo->quit = true;
+                break;
+            }
+            if (val == SCREEN_EVENT_NONE) {
+                break;
+            }
+            switch (val) {
+                case SCREEN_EVENT_KEYBOARD:
+                    rc = screen_get_event_property_iv(demo->screen_event, SCREEN_PROPERTY_FLAGS, &val);
+                    if (rc) {
+                        printf("Cannot get SCREEN_PROPERTY_FLAGS of the event! (%s)\n", strerror(errno));
+                        fflush(stdout);
+                        demo->quit = true;
+                        break;
+                    }
+                    if (val & KEY_DOWN) {
+                        rc = screen_get_event_property_iv(demo->screen_event, SCREEN_PROPERTY_SYM, &val);
+                        if (rc) {
+                            printf("Cannot get SCREEN_PROPERTY_SYM of the event! (%s)\n", strerror(errno));
+                            fflush(stdout);
+                            demo->quit = true;
+                            break;
+                        }
+                        switch (val) {
+                            case KEYCODE_ESCAPE:
+                                demo->quit = true;
+                                break;
+                            case KEYCODE_SPACE:
+                                demo->pause = !demo->pause;
+                                break;
+                            case KEYCODE_LEFT:
+                                demo->spin_angle -= demo->spin_increment;
+                                break;
+                            case KEYCODE_RIGHT:
+                                demo->spin_angle += demo->spin_increment;
+                                break;
+                            default:
+                                break;
+                        }
+                    }
+                    break;
+                case SCREEN_EVENT_PROPERTY:
+                    rc = screen_get_event_property_pv(demo->screen_event, SCREEN_PROPERTY_WINDOW, (void **)&win);
+                    if (rc) {
+                        printf("Cannot get SCREEN_PROPERTY_WINDOW of the event! (%s)\n", strerror(errno));
+                        fflush(stdout);
+                        demo->quit = true;
+                        break;
+                    }
+                    rc = screen_get_event_property_iv(demo->screen_event, SCREEN_PROPERTY_NAME, &val);
+                    if (rc) {
+                        printf("Cannot get SCREEN_PROPERTY_NAME of the event! (%s)\n", strerror(errno));
+                        fflush(stdout);
+                        demo->quit = true;
+                        break;
+                    }
+                    if (win == demo->screen_window) {
+                        switch (val) {
+                            case SCREEN_PROPERTY_SIZE:
+                                rc = screen_get_window_property_iv(win, SCREEN_PROPERTY_SIZE, size);
+                                if (rc) {
+                                    printf("Cannot get SCREEN_PROPERTY_SIZE of the window in the event! (%s)\n", strerror(errno));
+                                    fflush(stdout);
+                                    demo->quit = true;
+                                    break;
+                                }
+                                demo->width = size[0];
+                                demo->height = size[1];
+                                demo_resize(demo);
+                                break;
+                            default:
+                                /* We are not interested in any other events for now */
+                                break;
+                        }
+                    }
+                    break;
+            }
+        }
+
+        if (demo->pause || !demo->initialized || !demo->swapchain_ready) {
+        } else {
+            demo_draw(demo);
+            if (!demo->is_minimized) {
+                demo->curFrame++;
+            }
+            if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) {
+                demo->quit = true;
+            }
+        }
+    }
+}
+
+static void demo_create_screen_window(struct demo *demo) {
+    const char *idstr = APP_SHORT_NAME;
+    int size[2];
+    int usage = SCREEN_USAGE_VULKAN;
+    int rc;
+
+    rc = screen_create_context(&demo->screen_context, 0);
+    if (rc) {
+        printf("Cannot create QNX Screen context!\n");
+        fflush(stdout);
+        exit(EXIT_FAILURE);
+    }
+    rc = screen_create_window(&demo->screen_window, demo->screen_context);
+    if (rc) {
+        printf("Cannot create QNX Screen window!\n");
+        fflush(stdout);
+        exit(EXIT_FAILURE);
+    }
+    rc = screen_create_event(&demo->screen_event);
+    if (rc) {
+        printf("Cannot create QNX Screen event!\n");
+        fflush(stdout);
+        exit(EXIT_FAILURE);
+    }
+
+    /* Set window caption */
+    screen_set_window_property_cv(demo->screen_window, SCREEN_PROPERTY_ID_STRING, strlen(idstr), idstr);
+
+    /* Setup VULKAN usage flags */
+    rc = screen_set_window_property_iv(demo->screen_window, SCREEN_PROPERTY_USAGE, &usage);
+    if (rc) {
+        printf("Cannot set SCREEN_USAGE_VULKAN flag!\n");
+        fflush(stdout);
+        exit(EXIT_FAILURE);
+    }
+
+    /* Setup window size */
+    if ((demo->width == 0) || (demo->height == 0)) {
+        /* Obtain automatically set window size provided by WM */
+        rc = screen_get_window_property_iv(demo->screen_window, SCREEN_PROPERTY_SIZE, size);
+        if (rc) {
+            printf("Cannot obtain current window size!\n");
+            fflush(stdout);
+            exit(EXIT_FAILURE);
+        }
+        demo->width = size[0];
+        demo->height = size[1];
+    } else {
+        size[0] = demo->width;
+        size[1] = demo->height;
+        rc = screen_set_window_property_iv(demo->screen_window, SCREEN_PROPERTY_SIZE, size);
+        if (rc) {
+            printf("Cannot set window size!\n");
+            fflush(stdout);
+            exit(EXIT_FAILURE);
+        }
+    }
+}
+#endif
+
+/*
+ * Return 1 (true) if all layer names specified in check_names
+ * can be found in given layer properties.
+ */
+static VkBool32 demo_check_layers(uint32_t check_count, char **check_names, uint32_t layer_count, VkLayerProperties *layers) {
+    for (uint32_t i = 0; i < check_count; i++) {
+        VkBool32 found = 0;
+        for (uint32_t j = 0; j < layer_count; j++) {
+            if (!strcmp(check_names[i], layers[j].layerName)) {
+                found = 1;
+                break;
+            }
+        }
+        if (!found) {
+            fprintf(stderr, "Cannot find layer: %s\n", check_names[i]);
+            return 0;
+        }
+    }
+    return 1;
+}
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+int find_display_gpu(int gpu_number, uint32_t gpu_count, VkPhysicalDevice *physical_devices) {
+    uint32_t display_count = 0;
+    VkResult U_ASSERT_ONLY result;
+    int gpu_return = gpu_number;
+    if (gpu_number >= 0) {
+        result = vkGetPhysicalDeviceDisplayPropertiesKHR(physical_devices[gpu_number], &display_count, NULL);
+        assert(!result);
+    } else {
+        for (uint32_t i = 0; i < gpu_count; i++) {
+            result = vkGetPhysicalDeviceDisplayPropertiesKHR(physical_devices[i], &display_count, NULL);
+            assert(!result);
+            if (display_count) {
+                gpu_return = i;
+                break;
+            }
+        }
+    }
+    if (display_count > 0)
+        return gpu_return;
+    else
+        return -1;
+}
+#endif
+
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+static void pointer_handle_enter(void *data, struct wl_pointer *pointer, uint32_t serial, struct wl_surface *surface, wl_fixed_t sx,
+                                 wl_fixed_t sy) {}
+
+static void pointer_handle_leave(void *data, struct wl_pointer *pointer, uint32_t serial, struct wl_surface *surface) {}
+
+static void pointer_handle_motion(void *data, struct wl_pointer *pointer, uint32_t time, wl_fixed_t sx, wl_fixed_t sy) {}
+
+static void pointer_handle_button(void *data, struct wl_pointer *wl_pointer, uint32_t serial, uint32_t time, uint32_t button,
+                                  uint32_t state) {
+    struct demo *demo = data;
+    if (button == BTN_LEFT && state == WL_POINTER_BUTTON_STATE_PRESSED) {
+        xdg_toplevel_move(demo->xdg_toplevel, demo->seat, serial);
+    }
+}
+
+static void pointer_handle_axis(void *data, struct wl_pointer *wl_pointer, uint32_t time, uint32_t axis, wl_fixed_t value) {}
+
+static const struct wl_pointer_listener pointer_listener = {
+    pointer_handle_enter, pointer_handle_leave, pointer_handle_motion, pointer_handle_button, pointer_handle_axis,
+};
+
+static void keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard, uint32_t format, int fd, uint32_t size) {}
+
+static void keyboard_handle_enter(void *data, struct wl_keyboard *keyboard, uint32_t serial, struct wl_surface *surface,
+                                  struct wl_array *keys) {}
+
+static void keyboard_handle_leave(void *data, struct wl_keyboard *keyboard, uint32_t serial, struct wl_surface *surface) {}
+
+static void keyboard_handle_key(void *data, struct wl_keyboard *keyboard, uint32_t serial, uint32_t time, uint32_t key,
+                                uint32_t state) {
+    if (state != WL_KEYBOARD_KEY_STATE_RELEASED) return;
+    struct demo *demo = data;
+    switch (key) {
+        case KEY_ESC:  // Escape
+            demo->quit = true;
+            break;
+        case KEY_LEFT:  // left arrow key
+            demo->spin_angle -= demo->spin_increment;
+            break;
+        case KEY_RIGHT:  // right arrow key
+            demo->spin_angle += demo->spin_increment;
+            break;
+        case KEY_SPACE:  // space bar
+            demo->pause = !demo->pause;
+            break;
+    }
+}
+
+static void keyboard_handle_modifiers(void *data, struct wl_keyboard *keyboard, uint32_t serial, uint32_t mods_depressed,
+                                      uint32_t mods_latched, uint32_t mods_locked, uint32_t group) {}
+
+static const struct wl_keyboard_listener keyboard_listener = {
+    keyboard_handle_keymap, keyboard_handle_enter, keyboard_handle_leave, keyboard_handle_key, keyboard_handle_modifiers,
+};
+
+static void seat_handle_capabilities(void *data, struct wl_seat *seat, enum wl_seat_capability caps) {
+    // Subscribe to pointer events
+    struct demo *demo = data;
+    if ((caps & WL_SEAT_CAPABILITY_POINTER) && !demo->pointer) {
+        demo->pointer = wl_seat_get_pointer(seat);
+        wl_pointer_add_listener(demo->pointer, &pointer_listener, demo);
+    } else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && demo->pointer) {
+        wl_pointer_destroy(demo->pointer);
+        demo->pointer = NULL;
+    }
+    // Subscribe to keyboard events
+    if (caps & WL_SEAT_CAPABILITY_KEYBOARD) {
+        demo->keyboard = wl_seat_get_keyboard(seat);
+        wl_keyboard_add_listener(demo->keyboard, &keyboard_listener, demo);
+    } else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && demo->keyboard) {
+        wl_keyboard_destroy(demo->keyboard);
+        demo->keyboard = NULL;
+    }
+}
+
+static const struct wl_seat_listener seat_listener = {
+    seat_handle_capabilities,
+};
+
+static void wm_base_ping(void *data UNUSED, struct xdg_wm_base *xdg_wm_base, uint32_t serial) {
+    xdg_wm_base_pong(xdg_wm_base, serial);
+}
+
+static const struct xdg_wm_base_listener wm_base_listener = {wm_base_ping};
+
+static void registry_handle_global(void *data, struct wl_registry *registry, uint32_t id, const char *interface,
+                                   uint32_t version UNUSED) {
+    struct demo *demo = data;
+    // pickup wayland objects when they appear
+    if (strcmp(interface, wl_compositor_interface.name) == 0) {
+        uint32_t minVersion = version < 4 ? version : 4;
+        demo->compositor = wl_registry_bind(registry, id, &wl_compositor_interface, minVersion);
+        if (demo->VK_KHR_incremental_present_enabled && minVersion < 4) {
+            fprintf(stderr, "Wayland compositor doesn't support VK_KHR_incremental_present, disabling.\n");
+            demo->VK_KHR_incremental_present_enabled = false;
+        }
+    } else if (strcmp(interface, xdg_wm_base_interface.name) == 0) {
+        demo->xdg_wm_base = wl_registry_bind(registry, id, &xdg_wm_base_interface, 1);
+        xdg_wm_base_add_listener(demo->xdg_wm_base, &wm_base_listener, NULL);
+    } else if (strcmp(interface, wl_seat_interface.name) == 0) {
+        demo->seat = wl_registry_bind(registry, id, &wl_seat_interface, 1);
+        wl_seat_add_listener(demo->seat, &seat_listener, demo);
+    } else if (strcmp(interface, zxdg_decoration_manager_v1_interface.name) == 0) {
+        demo->xdg_decoration_mgr = wl_registry_bind(registry, id, &zxdg_decoration_manager_v1_interface, 1);
+    }
+}
+
+static void registry_handle_global_remove(void *data UNUSED, struct wl_registry *registry UNUSED, uint32_t name UNUSED) {}
+
+static const struct wl_registry_listener registry_listener = {registry_handle_global, registry_handle_global_remove};
+#endif
+
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+static const char *demo_init_xcb_connection(struct demo *demo) {
+    demo->xcb_library = initialize_xcb();
+    if (NULL == demo->xcb_library) {
+        return "Cannot load XCB dynamic library.";
+    }
+
+    const xcb_setup_t *setup;
+    xcb_screen_iterator_t iter;
+    int scr;
+
+    const char *display_envar = getenv("DISPLAY");
+    if (display_envar == NULL || display_envar[0] == '\0') {
+        return "Environment variable DISPLAY requires a valid value.n";
+    }
+
+    demo->connection = xcb_connect(NULL, &scr);
+    if (xcb_connection_has_error(demo->connection) > 0) {
+        return "Cannot connect to XCB.";
+    }
+
+    setup = xcb_get_setup(demo->connection);
+    iter = xcb_setup_roots_iterator(setup);
+    while (scr-- > 0) xcb_screen_next(&iter);
+
+    demo->screen = iter.data;
+    return NULL;
+}
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+static const char *demo_init_xlib_connection(struct demo *demo) {
+    demo->xlib_library = initialize_xlib();
+    if (NULL == demo->xlib_library) {
+        return "Cannot load XLIB dynamic library.";
+    }
+    return NULL;
+}
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+static const char *demo_init_wayland_connection(struct demo *demo) {
+    demo->wayland_library = initialize_wayland();
+    if (NULL == demo->wayland_library) {
+        return "Cannot load wayland dynamic library.";
+    }
+
+    demo->wayland_display = wl_display_connect(NULL);
+
+    if (demo->wayland_display == NULL) {
+        return "Cannot connect to wayland.";
+    }
+
+    demo->registry = wl_display_get_registry(demo->wayland_display);
+    wl_registry_add_listener(demo->registry, &registry_listener, demo);
+    wl_display_roundtrip(demo->wayland_display);
+    return NULL;
+}
+#endif
+
+// Check that WSI platforms are available - only necessary when multiple WSI platforms exist, like on linux
+// If the wsi_platform is AUTO, this function also sets wsi_platform to the first available WSI platform
+// Otherwise, it errors out if the specified wsi_platform isn't available
+static void demo_check_and_set_wsi_platform(struct demo *demo) {
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+    if (demo->wsi_platform == WSI_PLATFORM_WAYLAND || demo->wsi_platform == WSI_PLATFORM_AUTO) {
+        bool wayland_extension_available = false;
+        for (uint32_t i = 0; i < demo->enabled_extension_count; i++) {
+            if (strcmp(demo->extension_names[i], VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME) == 0) {
+                wayland_extension_available = true;
+                break;
+            }
+        }
+        if (wayland_extension_available) {
+            const char *error_msg = demo_init_wayland_connection(demo);
+            if (error_msg != NULL) {
+                if (demo->wsi_platform == WSI_PLATFORM_WAYLAND) {
+                    fprintf(stderr, "%s\nExiting ...\n", error_msg);
+                    fflush(stdout);
+                    exit(1);
+                }
+            } else {
+                demo->wsi_platform = WSI_PLATFORM_WAYLAND;
+                return;
+            }
+        }
+    }
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+    if (demo->wsi_platform == WSI_PLATFORM_XCB || demo->wsi_platform == WSI_PLATFORM_AUTO) {
+        bool xcb_extension_available = false;
+        for (uint32_t i = 0; i < demo->enabled_extension_count; i++) {
+            if (strcmp(demo->extension_names[i], VK_KHR_XCB_SURFACE_EXTENSION_NAME) == 0) {
+                xcb_extension_available = true;
+                break;
+            }
+        }
+        if (xcb_extension_available) {
+            const char *error_msg = demo_init_xcb_connection(demo);
+            if (error_msg != NULL) {
+                if (demo->wsi_platform == WSI_PLATFORM_XCB) {
+                    fprintf(stderr, "%s\nExiting ...\n", error_msg);
+                    fflush(stdout);
+                    exit(1);
+                }
+            } else {
+                demo->wsi_platform = WSI_PLATFORM_XCB;
+                return;
+            }
+        }
+    }
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+    if (demo->wsi_platform == WSI_PLATFORM_XLIB || demo->wsi_platform == WSI_PLATFORM_AUTO) {
+        bool xlib_extension_available = false;
+        for (uint32_t i = 0; i < demo->enabled_extension_count; i++) {
+            if (strcmp(demo->extension_names[i], VK_KHR_XLIB_SURFACE_EXTENSION_NAME) == 0) {
+                xlib_extension_available = true;
+                break;
+            }
+        }
+        if (xlib_extension_available) {
+            const char *error_msg = demo_init_xlib_connection(demo);
+            if (error_msg != NULL) {
+                if (demo->wsi_platform == WSI_PLATFORM_XLIB) {
+                    fprintf(stderr, "%s\nExiting ...\n", error_msg);
+                    fflush(stdout);
+                    exit(1);
+                }
+            } else {
+                demo->wsi_platform = WSI_PLATFORM_XLIB;
+                return;
+            }
+        }
+    }
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+    if (demo->wsi_platform == WSI_PLATFORM_DIRECTFB || demo->wsi_platform == WSI_PLATFORM_AUTO) {
+        bool direftfb_extension_available = false;
+        for (uint32_t i = 0; i < demo->enabled_extension_count; i++) {
+            if (strcmp(demo->extension_names[i], VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME) == 0) {
+                direftfb_extension_available = true;
+                break;
+            }
+        }
+        if (direftfb_extension_available) {
+            // Because DirectFB is still linked in, we can assume that it works if we got here
+            demo->wsi_platform = WSI_PLATFORM_DIRECTFB;
+            return;
+        }
+    }
+#endif
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+    if (demo->wsi_platform == WSI_PLATFORM_WIN32 || demo->wsi_platform == WSI_PLATFORM_AUTO) {
+        bool win32_extension_available = false;
+        for (uint32_t i = 0; i < demo->enabled_extension_count; i++) {
+            if (strcmp(demo->extension_names[i], VK_KHR_WIN32_SURFACE_EXTENSION_NAME) == 0) {
+                win32_extension_available = true;
+                break;
+            }
+        }
+        if (win32_extension_available) {
+            demo->wsi_platform = WSI_PLATFORM_WIN32;
+            return;
+        }
+    }
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+    if (demo->wsi_platform == WSI_PLATFORM_METAL || demo->wsi_platform == WSI_PLATFORM_AUTO) {
+        bool metal_extension_available = false;
+        for (uint32_t i = 0; i < demo->enabled_extension_count; i++) {
+            if (strcmp(demo->extension_names[i], VK_EXT_METAL_SURFACE_EXTENSION_NAME) == 0) {
+                metal_extension_available = true;
+                break;
+            }
+        }
+        if (metal_extension_available) {
+            demo->wsi_platform = WSI_PLATFORM_METAL;
+            return;
+        }
+    }
+#endif
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+    if (demo->wsi_platform == WSI_PLATFORM_ANDROID || demo->wsi_platform == WSI_PLATFORM_AUTO) {
+        bool android_extension_available = false;
+        for (uint32_t i = 0; i < demo->enabled_extension_count; i++) {
+            if (strcmp(demo->extension_names[i], VK_KHR_ANDROID_SURFACE_EXTENSION_NAME) == 0) {
+                android_extension_available = true;
+                break;
+            }
+        }
+        if (android_extension_available) {
+            demo->wsi_platform = WSI_PLATFORM_ANDROID;
+            return;
+        }
+    }
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+    if (demo->wsi_platform == WSI_PLATFORM_QNX || demo->wsi_platform == WSI_PLATFORM_AUTO) {
+        bool qnx_extension_available = false;
+        for (uint32_t i = 0; i < demo->enabled_extension_count; i++) {
+            if (strcmp(demo->extension_names[i], VK_QNX_SCREEN_SURFACE_EXTENSION_NAME) == 0) {
+                qnx_extension_available = true;
+                break;
+            }
+        }
+        if (qnx_extension_available) {
+            demo->wsi_platform = WSI_PLATFORM_QNX;
+            return;
+        }
+    }
+#endif
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+    if (demo->wsi_platform == WSI_PLATFORM_DISPLAY || demo->wsi_platform == WSI_PLATFORM_AUTO) {
+        bool display_extension_available = false;
+        for (uint32_t i = 0; i < demo->enabled_extension_count; i++) {
+            if (strcmp(demo->extension_names[i], VK_KHR_DISPLAY_EXTENSION_NAME) == 0) {
+                display_extension_available = true;
+                break;
+            }
+        }
+        if (display_extension_available) {
+            // Because DISPLAY doesn't require additional libraries, we can assume that it works if we got here
+            demo->wsi_platform = WSI_PLATFORM_DISPLAY;
+            return;
+        }
+    }
+#endif
+}
+
+static void demo_init_vk(struct demo *demo) {
+    VkResult err;
+    uint32_t instance_extension_count = 0;
+    uint32_t instance_layer_count = 0;
+    char *instance_validation_layers[] = {"VK_LAYER_KHRONOS_validation"};
+    demo->enabled_extension_count = 0;
+    demo->enabled_layer_count = 0;
+    demo->is_minimized = false;
+    demo->cmd_pool = VK_NULL_HANDLE;
+
+    err = load_vulkan_library();
+    if (err != VK_SUCCESS) {
+        ERR_EXIT(
+            "Unable to find the Vulkan runtime on the system.\n\n"
+            "This likely indicates that no Vulkan capable drivers are installed.",
+            "Installation Failure");
+    }
+    // Look for validation layers
+    VkBool32 validation_found = 0;
+    if (demo->validate) {
+        err = vkEnumerateInstanceLayerProperties(&instance_layer_count, NULL);
+        assert(!err);
+
+        if (instance_layer_count > 0) {
+            VkLayerProperties *instance_layers = malloc(sizeof(VkLayerProperties) * instance_layer_count);
+            err = vkEnumerateInstanceLayerProperties(&instance_layer_count, instance_layers);
+            assert(!err);
+
+            validation_found = demo_check_layers(ARRAY_SIZE(instance_validation_layers), instance_validation_layers,
+                                                 instance_layer_count, instance_layers);
+            if (validation_found) {
+                demo->enabled_layer_count = ARRAY_SIZE(instance_validation_layers);
+                demo->enabled_layers[0] = "VK_LAYER_KHRONOS_validation";
+            }
+            free(instance_layers);
+        }
+
+        if (!validation_found) {
+            ERR_EXIT(
+                "vkEnumerateInstanceLayerProperties failed to find required validation layer.\n\n"
+                "Please look at the Getting Started guide for additional information.\n",
+                "vkCreateInstance Failure");
+        }
+    }
+
+    /* Look for instance extensions */
+    VkBool32 surfaceExtFound = false;
+    VkBool32 platformSurfaceExtFound = false;
+    bool portabilityEnumerationActive = false;
+    memset(demo->extension_names, 0, sizeof(demo->extension_names));
+
+    err = vkEnumerateInstanceExtensionProperties(NULL, &instance_extension_count, NULL);
+    assert(!err);
+
+    if (instance_extension_count > 0) {
+        VkExtensionProperties *instance_extensions = malloc(sizeof(VkExtensionProperties) * instance_extension_count);
+        err = vkEnumerateInstanceExtensionProperties(NULL, &instance_extension_count, instance_extensions);
+        assert(!err);
+        for (uint32_t i = 0; i < instance_extension_count; i++) {
+            if (!strcmp(VK_KHR_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName)) {
+                surfaceExtFound = true;
+                demo->extension_names[demo->enabled_extension_count++] = VK_KHR_SURFACE_EXTENSION_NAME;
+            }
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+            if (!strcmp(VK_KHR_WIN32_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName) &&
+                (demo->wsi_platform == WSI_PLATFORM_AUTO || demo->wsi_platform == WSI_PLATFORM_WIN32)) {
+                platformSurfaceExtFound = true;
+                demo->extension_names[demo->enabled_extension_count++] = VK_KHR_WIN32_SURFACE_EXTENSION_NAME;
+            }
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+            if (!strcmp(VK_KHR_XLIB_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName) &&
+                (demo->wsi_platform == WSI_PLATFORM_AUTO || demo->wsi_platform == WSI_PLATFORM_XLIB)) {
+                platformSurfaceExtFound = true;
+                demo->extension_names[demo->enabled_extension_count++] = VK_KHR_XLIB_SURFACE_EXTENSION_NAME;
+            }
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+            if (!strcmp(VK_KHR_XCB_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName) &&
+                (demo->wsi_platform == WSI_PLATFORM_AUTO || demo->wsi_platform == WSI_PLATFORM_XCB)) {
+                platformSurfaceExtFound = true;
+                demo->extension_names[demo->enabled_extension_count++] = VK_KHR_XCB_SURFACE_EXTENSION_NAME;
+            }
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+            if (!strcmp(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName) &&
+                (demo->wsi_platform == WSI_PLATFORM_AUTO || demo->wsi_platform == WSI_PLATFORM_WAYLAND)) {
+                platformSurfaceExtFound = true;
+                demo->extension_names[demo->enabled_extension_count++] = VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME;
+            }
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+            if (!strcmp(VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName) &&
+                (demo->wsi_platform == WSI_PLATFORM_AUTO || demo->wsi_platform == WSI_PLATFORM_DIRECTFB)) {
+                platformSurfaceExtFound = true;
+                demo->extension_names[demo->enabled_extension_count++] = VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME;
+            }
+#endif
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+            if (!strcmp(VK_KHR_DISPLAY_EXTENSION_NAME, instance_extensions[i].extensionName) &&
+                (demo->wsi_platform == WSI_PLATFORM_AUTO || demo->wsi_platform == WSI_PLATFORM_DISPLAY)) {
+                platformSurfaceExtFound = true;
+                demo->extension_names[demo->enabled_extension_count++] = VK_KHR_DISPLAY_EXTENSION_NAME;
+            }
+#endif
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+            if (!strcmp(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName) &&
+                (demo->wsi_platform == WSI_PLATFORM_AUTO || demo->wsi_platform == WSI_PLATFORM_ANDROID)) {
+                platformSurfaceExtFound = true;
+                demo->extension_names[demo->enabled_extension_count++] = VK_KHR_ANDROID_SURFACE_EXTENSION_NAME;
+            }
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+            if (!strcmp(VK_EXT_METAL_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName) &&
+                (demo->wsi_platform == WSI_PLATFORM_AUTO || demo->wsi_platform == WSI_PLATFORM_METAL)) {
+                platformSurfaceExtFound = true;
+                demo->extension_names[demo->enabled_extension_count++] = VK_EXT_METAL_SURFACE_EXTENSION_NAME;
+            }
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+            if (!strcmp(VK_QNX_SCREEN_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName) &&
+                (demo->wsi_platform == WSI_PLATFORM_AUTO || demo->wsi_platform == WSI_PLATFORM_QNX)) {
+                platformSurfaceExtFound = true;
+                demo->extension_names[demo->enabled_extension_count++] = VK_QNX_SCREEN_SURFACE_EXTENSION_NAME;
+            }
+#endif
+            if (!strcmp(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, instance_extensions[i].extensionName)) {
+                demo->extension_names[demo->enabled_extension_count++] = VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME;
+            }
+            if (!strcmp(VK_EXT_DEBUG_UTILS_EXTENSION_NAME, instance_extensions[i].extensionName)) {
+                if (demo->validate) {
+                    demo->extension_names[demo->enabled_extension_count++] = VK_EXT_DEBUG_UTILS_EXTENSION_NAME;
+                }
+            }
+            // We want cube to be able to enumerate drivers that support the portability_subset extension, so we have to enable
+            // the portability enumeration extension.
+            if (!strcmp(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME, instance_extensions[i].extensionName)) {
+                portabilityEnumerationActive = true;
+                demo->extension_names[demo->enabled_extension_count++] = VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME;
+            }
+            assert(demo->enabled_extension_count < 64);
+        }
+
+        free(instance_extensions);
+    }
+
+    if (!surfaceExtFound) {
+        ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_SURFACE_EXTENSION_NAME
+                 " instance extension.\n\n"
+                 "This indicates that no compatible Vulkan installable client driver (ICD) is present or that the system is not "
+                 "configured to present to the screen. \n",
+                 "vkCreateInstance Failure");
+    }
+    if (!platformSurfaceExtFound) {
+        switch (demo->wsi_platform) {
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+            case (WSI_PLATFORM_WIN32):
+                ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_WIN32_SURFACE_EXTENSION_NAME
+                         " instance extension.\n\n"
+                         "The selected WSI platform win32 is not available, please choose a different WSI platform\n",
+                         "vkCreateInstance Failure");
+                break;
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+            case (WSI_PLATFORM_METAL):
+                ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_EXT_METAL_SURFACE_EXTENSION_NAME
+                         " instance extension.\n\n"
+                         "The selected WSI platform metal is not available, please choose a different WSI platform\n",
+                         "vkCreateInstance Failure");
+                break;
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+            case (WSI_PLATFORM_XCB):
+                ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_XCB_SURFACE_EXTENSION_NAME
+                         " instance extension.\n\n"
+                         "The selected WSI platform xcb is not available, please choose a different WSI platform\n",
+                         "vkCreateInstance Failure");
+                break;
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+            case (WSI_PLATFORM_WAYLAND):
+                ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME
+                         " instance extension.\n\n"
+                         "The selected WSI platform wayland is not available, please choose a different WSI platform\n",
+                         "vkCreateInstance Failure");
+                break;
+#endif
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+            case (WSI_PLATFORM_DISPLAY):
+                ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_DISPLAY_EXTENSION_NAME
+                         " instance extension.\n\n"
+                         "The selected WSI platform display is not available, please choose a different WSI platform\n",
+                         "vkCreateInstance Failure");
+                break;
+#endif
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+            case (WSI_PLATFORM_ANDROID):
+                ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_ANDROID_SURFACE_EXTENSION_NAME
+                         " instance extension.\n\n"
+                         "The selected WSI platform android is not available, please choose a different WSI platform\n",
+                         "vkCreateInstance Failure");
+                break;
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+            case (WSI_PLATFORM_XLIB):
+                ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_XLIB_SURFACE_EXTENSION_NAME
+                         " instance extension.\n\n"
+                         "The selected WSI platform xlib is not available, please choose a different WSI platform\n",
+                         "vkCreateInstance Failure");
+                break;
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+            case (WSI_PLATFORM_DIRECTFB):
+                ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME
+                         " instance extension.\n\n"
+                         "The selected WSI platform directfb is not available, please choose a different WSI platform\n",
+                         "vkCreateInstance Failure");
+                break;
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+            case (WSI_PLATFORM_QNX):
+                ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_QNX_SCREEN_SURFACE_EXTENSION_NAME
+                         " instance extension.\n\n"
+                         "The selected WSI platform qnx is not available, please choose a different WSI platform\n",
+                         "vkCreateInstance Failure");
+                break;
+#endif
+            default:
+            case (WSI_PLATFORM_AUTO):
+                // Getting here indicates we are using the WSI extension that is default on this platform
+                ERR_EXIT(
+                    "vkEnumerateInstanceExtensionProperties failed to find any supported WSI surface instance extensions.\n\n"
+                    "This indicates that no compatible Vulkan installable client driver (ICD) is present or that the system is not "
+                    "configured to present to the screen. \n",
+                    "vkCreateInstance Failure");
+                break;
+        }
+    }
+
+    bool auto_wsi_platform = demo->wsi_platform == WSI_PLATFORM_AUTO;
+
+    demo_check_and_set_wsi_platform(demo);
+
+    // Print a message to indicate the automatically set WSI platform
+    if (auto_wsi_platform && demo->wsi_platform != WSI_PLATFORM_AUTO) {
+        fprintf(stderr, "Selected WSI platform: %s\n", wsi_to_string(demo->wsi_platform));
+    }
+
+    const VkApplicationInfo app = {
+        .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
+        .pNext = NULL,
+        .pApplicationName = APP_SHORT_NAME,
+        .applicationVersion = 0,
+        .pEngineName = APP_SHORT_NAME,
+        .engineVersion = 0,
+        .apiVersion = VK_API_VERSION_1_0,
+    };
+    VkInstanceCreateInfo inst_info = {
+        .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
+        .pNext = NULL,
+        .flags = (portabilityEnumerationActive ? VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR : 0),
+        .pApplicationInfo = &app,
+        .enabledLayerCount = demo->enabled_layer_count,
+        .ppEnabledLayerNames = (const char *const *)instance_validation_layers,
+        .enabledExtensionCount = demo->enabled_extension_count,
+        .ppEnabledExtensionNames = (const char *const *)demo->extension_names,
+    };
+
+    /*
+     * This is info for a temp callback to use during CreateInstance.
+     * After the instance is created, we use the instance-based
+     * function to register the final callback.
+     */
+    VkDebugUtilsMessengerCreateInfoEXT dbg_messenger_create_info;
+    if (demo->validate) {
+        // VK_EXT_debug_utils style
+        dbg_messenger_create_info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
+        dbg_messenger_create_info.pNext = NULL;
+        dbg_messenger_create_info.flags = 0;
+        dbg_messenger_create_info.messageSeverity =
+            VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
+        dbg_messenger_create_info.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |
+                                                VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT |
+                                                VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
+        dbg_messenger_create_info.pfnUserCallback = debug_messenger_callback;
+        dbg_messenger_create_info.pUserData = demo;
+        inst_info.pNext = &dbg_messenger_create_info;
+    }
+
+    err = vkCreateInstance(&inst_info, NULL, &demo->inst);
+    if (err == VK_ERROR_INCOMPATIBLE_DRIVER) {
+        ERR_EXIT(
+            "Cannot find a compatible Vulkan installable client driver (ICD).\n\n"
+            "Please look at the Getting Started guide for additional information.\n",
+            "vkCreateInstance Failure");
+    } else if (err == VK_ERROR_EXTENSION_NOT_PRESENT) {
+        ERR_EXIT(
+            "Cannot find a specified extension library.\n"
+            "Make sure your layers path is set appropriately.\n",
+            "vkCreateInstance Failure");
+    } else if (err) {
+        ERR_EXIT(
+            "vkCreateInstance failed.\n\n"
+            "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
+            "Please look at the Getting Started guide for additional information.\n",
+            "vkCreateInstance Failure");
+    }
+
+    load_vulkan_instance_functions(demo->inst);
+}
+
+static void demo_select_physical_device(struct demo *demo) {
+    VkResult err;
+    /* Make initial call to query gpu_count, then second call for gpu info */
+    uint32_t gpu_count = 0;
+    err = vkEnumeratePhysicalDevices(demo->inst, &gpu_count, NULL);
+    assert(!err);
+
+    if (gpu_count <= 0) {
+        ERR_EXIT(
+            "vkEnumeratePhysicalDevices reported zero accessible devices.\n\n"
+            "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
+            "Please look at the Getting Started guide for additional information.\n",
+            "vkEnumeratePhysicalDevices Failure");
+    }
+
+    VkPhysicalDevice *physical_devices = malloc(sizeof(VkPhysicalDevice) * gpu_count);
+    err = vkEnumeratePhysicalDevices(demo->inst, &gpu_count, physical_devices);
+    assert(!err);
+    if (demo->invalid_gpu_selection || (demo->gpu_number >= 0 && !((uint32_t)demo->gpu_number < gpu_count))) {
+        fprintf(stderr, "GPU %d specified is not present, GPU count = %u\n", demo->gpu_number, gpu_count);
+        ERR_EXIT("Specified GPU number is not present", "User Error");
+    }
+
+    if (demo->wsi_platform == WSI_PLATFORM_DISPLAY) {
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+        demo->gpu_number = find_display_gpu(demo->gpu_number, gpu_count, physical_devices);
+        if (demo->gpu_number < 0) {
+            printf("Cannot find any display!\n");
+            fflush(stdout);
+            exit(1);
+        }
+#else
+        printf("WSI selection was set to DISPLAY but vkcube was not compiled with support for the DISPLAY platform, exiting \n");
+        fflush(stdout);
+        exit(1);
+#endif
+    } else {
+        /* Try to auto select most suitable device */
+        if (demo->gpu_number == -1) {
+            VkPhysicalDeviceProperties physicalDeviceProperties;
+            int prev_priority = 0;
+            for (uint32_t i = 0; i < gpu_count; i++) {
+                vkGetPhysicalDeviceProperties(physical_devices[i], &physicalDeviceProperties);
+                assert(physicalDeviceProperties.deviceType <= VK_PHYSICAL_DEVICE_TYPE_CPU);
+
+                // Continue next gpu if this gpu does not support the surface.
+                VkBool32 supported = VK_FALSE;
+                VkResult result = vkGetPhysicalDeviceSurfaceSupportKHR(physical_devices[i], 0, demo->surface, &supported);
+                if (result != VK_SUCCESS || !supported) continue;
+
+                int priority = 0;
+                switch (physicalDeviceProperties.deviceType) {
+                    case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:
+                        priority = 5;
+                        break;
+                    case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU:
+                        priority = 4;
+                        break;
+                    case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU:
+                        priority = 3;
+                        break;
+                    case VK_PHYSICAL_DEVICE_TYPE_CPU:
+                        priority = 2;
+                        break;
+                    case VK_PHYSICAL_DEVICE_TYPE_OTHER:
+                        priority = 1;
+                        break;
+                    default:
+                        priority = -1;
+                        break;
+                }
+
+                if (priority > prev_priority) {
+                    demo->gpu_number = i;
+                    prev_priority = priority;
+                }
+            }
+        }
+    }
+
+    assert(demo->gpu_number >= 0);
+    demo->gpu = physical_devices[demo->gpu_number];
+    {
+        VkPhysicalDeviceProperties physicalDeviceProperties;
+        vkGetPhysicalDeviceProperties(demo->gpu, &physicalDeviceProperties);
+        fprintf(stderr, "Selected GPU %d: %s, type: %s\n", demo->gpu_number, physicalDeviceProperties.deviceName,
+                to_string(physicalDeviceProperties.deviceType));
+    }
+    free(physical_devices);
+
+    /* Look for device extensions */
+    uint32_t device_extension_count = 0;
+    VkBool32 swapchainExtFound = 0;
+    demo->enabled_extension_count = 0;
+    memset(demo->extension_names, 0, sizeof(demo->extension_names));
+
+    err = vkEnumerateDeviceExtensionProperties(demo->gpu, NULL, &device_extension_count, NULL);
+    assert(!err);
+
+    if (device_extension_count > 0) {
+        VkExtensionProperties *device_extensions = malloc(sizeof(VkExtensionProperties) * device_extension_count);
+        err = vkEnumerateDeviceExtensionProperties(demo->gpu, NULL, &device_extension_count, device_extensions);
+        assert(!err);
+
+        for (uint32_t i = 0; i < device_extension_count; i++) {
+            if (!strcmp(VK_KHR_SWAPCHAIN_EXTENSION_NAME, device_extensions[i].extensionName)) {
+                swapchainExtFound = 1;
+                demo->extension_names[demo->enabled_extension_count++] = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
+            }
+            if (!strcmp("VK_KHR_portability_subset", device_extensions[i].extensionName)) {
+                demo->extension_names[demo->enabled_extension_count++] = "VK_KHR_portability_subset";
+            }
+            assert(demo->enabled_extension_count < 64);
+        }
+
+        if (demo->VK_KHR_incremental_present_enabled) {
+            // Even though the user "enabled" the extension via the command
+            // line, we must make sure that it's enumerated for use with the
+            // device.  Therefore, disable it here, and re-enable it again if
+            // enumerated.
+            demo->VK_KHR_incremental_present_enabled = false;
+            for (uint32_t i = 0; i < device_extension_count; i++) {
+                if (!strcmp(VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME, device_extensions[i].extensionName)) {
+                    demo->extension_names[demo->enabled_extension_count++] = VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME;
+                    demo->VK_KHR_incremental_present_enabled = true;
+                    DbgMsg("VK_KHR_incremental_present extension enabled\n");
+                }
+                assert(demo->enabled_extension_count < 64);
+            }
+            if (!demo->VK_KHR_incremental_present_enabled) {
+                DbgMsg("VK_KHR_incremental_present extension NOT AVAILABLE\n");
+            }
+        }
+
+        if (demo->VK_GOOGLE_display_timing_enabled) {
+            // Even though the user "enabled" the extension via the command
+            // line, we must make sure that it's enumerated for use with the
+            // device.  Therefore, disable it here, and re-enable it again if
+            // enumerated.
+            demo->VK_GOOGLE_display_timing_enabled = false;
+            for (uint32_t i = 0; i < device_extension_count; i++) {
+                if (!strcmp(VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME, device_extensions[i].extensionName)) {
+                    demo->extension_names[demo->enabled_extension_count++] = VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME;
+                    demo->VK_GOOGLE_display_timing_enabled = true;
+                    DbgMsg("VK_GOOGLE_display_timing extension enabled\n");
+                }
+                assert(demo->enabled_extension_count < 64);
+            }
+            if (!demo->VK_GOOGLE_display_timing_enabled) {
+                DbgMsg("VK_GOOGLE_display_timing extension NOT AVAILABLE\n");
+            }
+        }
+
+        free(device_extensions);
+    }
+
+    if (!swapchainExtFound) {
+        ERR_EXIT("vkEnumerateDeviceExtensionProperties failed to find the " VK_KHR_SWAPCHAIN_EXTENSION_NAME
+                 " extension.\n\nDo you have a compatible Vulkan installable client driver (ICD) installed?\n"
+                 "Please look at the Getting Started guide for additional information.\n",
+                 "vkCreateInstance Failure");
+    }
+
+    if (demo->validate) {
+        /*
+         * This is info for a temp callback to use during CreateInstance.
+         * After the instance is created, we use the instance-based
+         * function to register the final callback.
+         */
+        VkDebugUtilsMessengerCreateInfoEXT dbg_messenger_create_info;
+        // VK_EXT_debug_utils style
+        dbg_messenger_create_info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
+        dbg_messenger_create_info.pNext = NULL;
+        dbg_messenger_create_info.flags = 0;
+        dbg_messenger_create_info.messageSeverity =
+            VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
+        dbg_messenger_create_info.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |
+                                                VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT |
+                                                VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
+        dbg_messenger_create_info.pfnUserCallback = debug_messenger_callback;
+        dbg_messenger_create_info.pUserData = demo;
+
+        err = vkCreateDebugUtilsMessengerEXT(demo->inst, &dbg_messenger_create_info, NULL, &demo->dbg_messenger);
+        switch (err) {
+            case VK_SUCCESS:
+                break;
+            case VK_ERROR_OUT_OF_HOST_MEMORY:
+                ERR_EXIT("CreateDebugUtilsMessengerEXT: out of host memory\n", "CreateDebugUtilsMessengerEXT Failure");
+                break;
+            default:
+                ERR_EXIT("CreateDebugUtilsMessengerEXT: unknown failure\n", "CreateDebugUtilsMessengerEXT Failure");
+                break;
+        }
+    }
+    vkGetPhysicalDeviceProperties(demo->gpu, &demo->gpu_props);
+
+    /* Call with NULL data to get count */
+    vkGetPhysicalDeviceQueueFamilyProperties(demo->gpu, &demo->queue_family_count, NULL);
+    assert(demo->queue_family_count >= 1);
+
+    demo->queue_props = (VkQueueFamilyProperties *)malloc(demo->queue_family_count * sizeof(VkQueueFamilyProperties));
+    vkGetPhysicalDeviceQueueFamilyProperties(demo->gpu, &demo->queue_family_count, demo->queue_props);
+
+    // Query fine-grained feature support for this device.
+    //  If app has specific feature requirements it should check supported
+    //  features based on this query
+    VkPhysicalDeviceFeatures physDevFeatures;
+    vkGetPhysicalDeviceFeatures(demo->gpu, &physDevFeatures);
+}
+
+static void demo_create_device(struct demo *demo) {
+    VkResult U_ASSERT_ONLY err;
+    float queue_priorities[1] = {0.0};
+    VkDeviceQueueCreateInfo queues[2];
+    queues[0].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+    queues[0].pNext = NULL;
+    queues[0].queueFamilyIndex = demo->graphics_queue_family_index;
+    queues[0].queueCount = 1;
+    queues[0].pQueuePriorities = queue_priorities;
+    queues[0].flags = 0;
+
+    VkDeviceCreateInfo device = {
+        .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
+        .pNext = NULL,
+        .queueCreateInfoCount = 1,
+        .pQueueCreateInfos = queues,
+        .enabledLayerCount = 0,
+        .ppEnabledLayerNames = NULL,
+        .enabledExtensionCount = demo->enabled_extension_count,
+        .ppEnabledExtensionNames = (const char *const *)demo->extension_names,
+        .pEnabledFeatures = NULL,  // If specific features are required, pass them in here
+    };
+    if (demo->separate_present_queue) {
+        queues[1].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+        queues[1].pNext = NULL;
+        queues[1].queueFamilyIndex = demo->present_queue_family_index;
+        queues[1].queueCount = 1;
+        queues[1].pQueuePriorities = queue_priorities;
+        queues[1].flags = 0;
+        device.queueCreateInfoCount = 2;
+    }
+    err = vkCreateDevice(demo->gpu, &device, NULL, &demo->device);
+    assert(!err);
+
+    load_vulkan_device_functions(demo->device);
+}
+
+static void demo_create_surface(struct demo *demo) {
+    VkResult U_ASSERT_ONLY err = VK_SUCCESS;
+
+// Create a WSI surface for the window:
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+    if (demo->wsi_platform == WSI_PLATFORM_WIN32) {
+        VkWin32SurfaceCreateInfoKHR win32_createInfo;
+        win32_createInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
+        win32_createInfo.pNext = NULL;
+        win32_createInfo.flags = 0;
+        win32_createInfo.hinstance = demo->connection;
+        win32_createInfo.hwnd = demo->window;
+
+        err = vkCreateWin32SurfaceKHR(demo->inst, &win32_createInfo, NULL, &demo->surface);
+    }
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+    if (demo->wsi_platform == WSI_PLATFORM_WAYLAND) {
+        VkWaylandSurfaceCreateInfoKHR wayland_createInfo;
+        wayland_createInfo.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
+        wayland_createInfo.pNext = NULL;
+        wayland_createInfo.flags = 0;
+        wayland_createInfo.display = demo->wayland_display;
+        wayland_createInfo.surface = demo->window;
+
+        err = vkCreateWaylandSurfaceKHR(demo->inst, &wayland_createInfo, NULL, &demo->surface);
+    }
+#endif
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+    if (demo->wsi_platform == WSI_PLATFORM_ANDROID) {
+        VkAndroidSurfaceCreateInfoKHR android_createInfo;
+        android_createInfo.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
+        android_createInfo.pNext = NULL;
+        android_createInfo.flags = 0;
+        android_createInfo.window = (struct ANativeWindow *)(demo->window);
+
+        err = vkCreateAndroidSurfaceKHR(demo->inst, &android_createInfo, NULL, &demo->surface);
+    }
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+    if (demo->wsi_platform == WSI_PLATFORM_XLIB) {
+        VkXlibSurfaceCreateInfoKHR xlib_createInfo;
+        xlib_createInfo.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
+        xlib_createInfo.pNext = NULL;
+        xlib_createInfo.flags = 0;
+        xlib_createInfo.dpy = demo->xlib_display;
+        xlib_createInfo.window = demo->xlib_window;
+
+        err = vkCreateXlibSurfaceKHR(demo->inst, &xlib_createInfo, NULL, &demo->surface);
+    }
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+    if (demo->wsi_platform == WSI_PLATFORM_XCB) {
+        VkXcbSurfaceCreateInfoKHR xcb_createInfo;
+        xcb_createInfo.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
+        xcb_createInfo.pNext = NULL;
+        xcb_createInfo.flags = 0;
+        xcb_createInfo.connection = demo->connection;
+        xcb_createInfo.window = demo->xcb_window;
+
+        err = vkCreateXcbSurfaceKHR(demo->inst, &xcb_createInfo, NULL, &demo->surface);
+    }
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+    if (demo->wsi_platform == WSI_PLATFORM_DIRECTFB) {
+        VkDirectFBSurfaceCreateInfoEXT directfb_createInfo;
+        directfb_createInfo.sType = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT;
+        directfb_createInfo.pNext = NULL;
+        directfb_createInfo.flags = 0;
+        directfb_createInfo.dfb = demo->dfb;
+        directfb_createInfo.surface = demo->directfb_window;
+
+        err = vkCreateDirectFBSurfaceEXT(demo->inst, &directfb_createInfo, NULL, &demo->surface);
+    }
+
+#endif
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+    if (demo->wsi_platform == WSI_PLATFORM_DISPLAY) {
+        err = demo_create_display_surface(demo);
+    }
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+    if (demo->wsi_platform == WSI_PLATFORM_METAL) {
+        VkMetalSurfaceCreateInfoEXT metal_createInfo;
+        metal_createInfo.sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT;
+        metal_createInfo.pNext = NULL;
+        metal_createInfo.flags = 0;
+        metal_createInfo.pLayer = demo->caMetalLayer;
+
+        err = vkCreateMetalSurfaceEXT(demo->inst, &metal_createInfo, NULL, &demo->surface);
+    }
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+    if (demo->wsi_platform == WSI_PLATFORM_QNX) {
+        VkScreenSurfaceCreateInfoQNX qnx_createInfo;
+        qnx_createInfo.sType = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX;
+        qnx_createInfo.pNext = NULL;
+        qnx_createInfo.flags = 0;
+        qnx_createInfo.context = demo->screen_context;
+        qnx_createInfo.window = demo->screen_window;
+
+        err = vkCreateScreenSurfaceQNX(demo->inst, &qnx_createInfo, NULL, &demo->surface);
+    }
+#endif
+    assert(!err);
+}
+
+static VkSurfaceFormatKHR pick_surface_format(const VkSurfaceFormatKHR *surfaceFormats, uint32_t count) {
+    // Prefer non-SRGB formats...
+    for (uint32_t i = 0; i < count; i++) {
+        const VkFormat format = surfaceFormats[i].format;
+
+        if (format == VK_FORMAT_R8G8B8A8_UNORM || format == VK_FORMAT_B8G8R8A8_UNORM ||
+            format == VK_FORMAT_A2B10G10R10_UNORM_PACK32 || format == VK_FORMAT_A2R10G10B10_UNORM_PACK32 ||
+            format == VK_FORMAT_A1R5G5B5_UNORM_PACK16 || format == VK_FORMAT_R5G6B5_UNORM_PACK16 ||
+            format == VK_FORMAT_R16G16B16A16_SFLOAT) {
+            return surfaceFormats[i];
+        }
+    }
+
+    printf("Can't find our preferred formats... Falling back to first exposed format. Rendering may be incorrect.\n");
+
+    assert(count >= 1);
+    return surfaceFormats[0];
+}
+
+static void demo_init_vk_swapchain(struct demo *demo) {
+    VkResult U_ASSERT_ONLY err;
+
+    // Iterate over each queue to learn whether it supports presenting:
+    VkBool32 *supportsPresent = (VkBool32 *)malloc(demo->queue_family_count * sizeof(VkBool32));
+    for (uint32_t i = 0; i < demo->queue_family_count; i++) {
+        vkGetPhysicalDeviceSurfaceSupportKHR(demo->gpu, i, demo->surface, &supportsPresent[i]);
+    }
+
+    // Search for a graphics and a present queue in the array of queue
+    // families, try to find one that supports both
+    uint32_t graphicsQueueFamilyIndex = UINT32_MAX;
+    uint32_t presentQueueFamilyIndex = UINT32_MAX;
+    for (uint32_t i = 0; i < demo->queue_family_count; i++) {
+        if ((demo->queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) != 0) {
+            if (graphicsQueueFamilyIndex == UINT32_MAX) {
+                graphicsQueueFamilyIndex = i;
+            }
+
+            if (supportsPresent[i] == VK_TRUE) {
+                graphicsQueueFamilyIndex = i;
+                presentQueueFamilyIndex = i;
+                break;
+            }
+        }
+    }
+
+    if (presentQueueFamilyIndex == UINT32_MAX) {
+        // If didn't find a queue that supports both graphics and present, then
+        // find a separate present queue.
+        for (uint32_t i = 0; i < demo->queue_family_count; ++i) {
+            if (supportsPresent[i] == VK_TRUE) {
+                presentQueueFamilyIndex = i;
+                break;
+            }
+        }
+    }
+
+    // Generate error if could not find both a graphics and a present queue
+    if (graphicsQueueFamilyIndex == UINT32_MAX || presentQueueFamilyIndex == UINT32_MAX) {
+        ERR_EXIT("Could not find both graphics and present queues\n", "Swapchain Initialization Failure");
+    }
+
+    demo->graphics_queue_family_index = graphicsQueueFamilyIndex;
+    demo->present_queue_family_index = presentQueueFamilyIndex;
+    demo->separate_present_queue = (demo->graphics_queue_family_index != demo->present_queue_family_index);
+    free(supportsPresent);
+
+    demo_create_device(demo);
+
+    vkGetDeviceQueue(demo->device, demo->graphics_queue_family_index, 0, &demo->graphics_queue);
+
+    if (!demo->separate_present_queue) {
+        demo->present_queue = demo->graphics_queue;
+    } else {
+        vkGetDeviceQueue(demo->device, demo->present_queue_family_index, 0, &demo->present_queue);
+    }
+
+    // Get the list of VkFormat's that are supported:
+    uint32_t formatCount;
+    err = vkGetPhysicalDeviceSurfaceFormatsKHR(demo->gpu, demo->surface, &formatCount, NULL);
+    assert(!err);
+    VkSurfaceFormatKHR *surfFormats = (VkSurfaceFormatKHR *)malloc(formatCount * sizeof(VkSurfaceFormatKHR));
+    err = vkGetPhysicalDeviceSurfaceFormatsKHR(demo->gpu, demo->surface, &formatCount, surfFormats);
+    assert(!err);
+    VkSurfaceFormatKHR surfaceFormat = pick_surface_format(surfFormats, formatCount);
+    demo->format = surfaceFormat.format;
+    demo->color_space = surfaceFormat.colorSpace;
+    free(surfFormats);
+
+    demo->quit = false;
+    demo->curFrame = 0;
+
+    demo->first_swapchain_frame = true;
+
+    // Get Memory information and properties
+    vkGetPhysicalDeviceMemoryProperties(demo->gpu, &demo->memory_properties);
+}
+
+static void demo_init(struct demo *demo, int argc, char **argv) {
+    vec3 eye = {0.0f, 3.0f, 5.0f};
+    vec3 origin = {0, 0, 0};
+    vec3 up = {0.0f, 1.0f, 0.0};
+
+    memset(demo, 0, sizeof(*demo));
+    demo->presentMode = VK_PRESENT_MODE_FIFO_KHR;
+    demo->frameCount = INT32_MAX;
+    /* Autodetect suitable / best GPU by default */
+    demo->gpu_number = -1;
+    demo->width = 500;
+    demo->height = 500;
+
+    for (int i = 1; i < argc; i++) {
+        if (strcmp(argv[i], "--use_staging") == 0) {
+            demo->use_staging_buffer = true;
+            continue;
+        }
+        if ((strcmp(argv[i], "--present_mode") == 0) && (i < argc - 1)) {
+            demo->presentMode = atoi(argv[i + 1]);
+            i++;
+            continue;
+        }
+        if (strcmp(argv[i], "--break") == 0) {
+            demo->use_break = true;
+            continue;
+        }
+        if (strcmp(argv[i], "--validate") == 0) {
+            demo->validate = true;
+            continue;
+        }
+        if (strcmp(argv[i], "--xlib") == 0) {
+            fprintf(stderr, "--xlib is deprecated and no longer does anything\n");
+            continue;
+        }
+        if (strcmp(argv[i], "--c") == 0 && demo->frameCount == INT32_MAX && i < argc - 1 &&
+            sscanf(argv[i + 1], "%d", &demo->frameCount) == 1 && demo->frameCount >= 0) {
+            i++;
+            continue;
+        }
+        if (strcmp(argv[i], "--width") == 0) {
+            if (i < argc - 1 && sscanf(argv[i + 1], "%d", &demo->width) == 1) {
+                if (demo->width > 0) {
+                    i++;
+                    continue;
+                } else {
+                    ERR_EXIT("The --width parameter must be greater than 0", "User Error");
+                }
+            }
+            ERR_EXIT("The --width parameter must be followed by a number", "User Error");
+        }
+        if (strcmp(argv[i], "--height") == 0) {
+            if (i < argc - 1 && sscanf(argv[i + 1], "%d", &demo->height) == 1) {
+                if (demo->height > 0) {
+                    i++;
+                    continue;
+                } else {
+                    ERR_EXIT("The --height parameter must be greater than 0", "User Error");
+                }
+            }
+            ERR_EXIT("The --height parameter must be followed by a number", "User Error");
+        }
+        if (strcmp(argv[i], "--suppress_popups") == 0) {
+            demo->suppress_popups = true;
+            continue;
+        }
+        if (strcmp(argv[i], "--display_timing") == 0) {
+            demo->VK_GOOGLE_display_timing_enabled = true;
+            continue;
+        }
+        if (strcmp(argv[i], "--incremental_present") == 0) {
+            demo->VK_KHR_incremental_present_enabled = true;
+            continue;
+        }
+        if ((strcmp(argv[i], "--gpu_number") == 0) && (i < argc - 1)) {
+            demo->gpu_number = atoi(argv[i + 1]);
+            if (demo->gpu_number < 0) demo->invalid_gpu_selection = true;
+            i++;
+            continue;
+        }
+        if (strcmp(argv[i], "--force_errors") == 0) {
+            demo->force_errors = true;
+            continue;
+        }
+        if ((strcmp(argv[i], "--wsi") == 0) && (i < argc - 1)) {
+            size_t argc_len = strlen(argv[i + 1]);
+            for (size_t argc_i = 0; argc_i < argc_len; argc_i++) {
+                argv[i + 1][argc_i] = tolower(argv[i + 1][argc_i]);
+            }
+            WSI_PLATFORM selection = wsi_from_string(argv[i + 1]);
+            if (selection == WSI_PLATFORM_INVALID) {
+                printf(
+                    "The --wsi parameter %s is not a supported WSI platform. The list of available platforms is available from "
+                    "--help\n",
+                    (const char *)&(argv[i + 1][0]));
+                fflush(stdout);
+                exit(1);
+            }
+            demo->wsi_platform = selection;
+            i++;
+            continue;
+        }
+#if defined(ANDROID)
+        ERR_EXIT("Usage: vkcube [--validate]\n", "Usage");
+#else
+
+        // Making the help for --wsi nice requires a little extra work since the list depends on what is available at
+        // compile time
+        size_t max_str_len = 100;
+        char *available_wsi_platforms = (char *)malloc(max_str_len);
+        memset(available_wsi_platforms, 0, max_str_len);
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+        strncat(available_wsi_platforms, "xcb", max_str_len);
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+        if (strlen(available_wsi_platforms) > 0) {
+            strncat(available_wsi_platforms, "|", max_str_len);
+        }
+        strncat(available_wsi_platforms, "xlib", max_str_len);
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+        if (strlen(available_wsi_platforms) > 0) {
+            strncat(available_wsi_platforms, "|", max_str_len);
+        }
+        strncat(available_wsi_platforms, "wayland", max_str_len);
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+        if (strlen(available_wsi_platforms) > 0) {
+            strncat(available_wsi_platforms, "|", max_str_len);
+        }
+        strncat(available_wsi_platforms, "directfb", max_str_len);
+#endif
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+        if (strlen(available_wsi_platforms) > 0) {
+            strncat(available_wsi_platforms, "|", max_str_len);
+        }
+        strncat(available_wsi_platforms, "display", max_str_len);
+#endif
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+        if (strlen(available_wsi_platforms) > 0) {
+            strncat(available_wsi_platforms, "|", max_str_len);
+        }
+        strncat(available_wsi_platforms, "win32", max_str_len);
+#endif
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+        if (strlen(available_wsi_platforms) > 0) {
+            strncat(available_wsi_platforms, "|", max_str_len);
+        }
+        strncat(available_wsi_platforms, "android", max_str_len);
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+        if (strlen(available_wsi_platforms) > 0) {
+            strncat(available_wsi_platforms, "|", max_str_len);
+        }
+        strncat(available_wsi_platforms, "metal", max_str_len);
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+        if (strlen(available_wsi_platforms) > 0) {
+            strncat(available_wsi_platforms, "|", max_str_len);
+        }
+        strncat(available_wsi_platforms, "qnx", max_str_len);
+#endif
+
+        char *message =
+            "Usage:\n  %s\t[--use_staging] [--validate]\n"
+            "\t[--break] [--c <framecount>] [--suppress_popups]\n"
+            "\t[--incremental_present] [--display_timing]\n"
+            "\t[--gpu_number <index of physical device>]\n"
+            "\t[--present_mode <present mode enum>]\n"
+            "\t[--width <width>] [--height <height>]\n"
+            "\t[--force_errors]\n"
+            "\t[--wsi <%s>]\n"
+            "\t<present_mode_enum>\n"
+            "\t\tVK_PRESENT_MODE_IMMEDIATE_KHR = %d\n"
+            "\t\tVK_PRESENT_MODE_MAILBOX_KHR = %d\n"
+            "\t\tVK_PRESENT_MODE_FIFO_KHR = %d\n"
+            "\t\tVK_PRESENT_MODE_FIFO_RELAXED_KHR = %d\n";
+        int length = snprintf(NULL, 0, message, APP_SHORT_NAME, available_wsi_platforms, VK_PRESENT_MODE_IMMEDIATE_KHR,
+                              VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR, VK_PRESENT_MODE_FIFO_RELAXED_KHR);
+        char *usage = (char *)malloc(length + 1);
+        if (!usage) {
+            exit(1);
+        }
+        snprintf(usage, length + 1, message, APP_SHORT_NAME, available_wsi_platforms, VK_PRESENT_MODE_IMMEDIATE_KHR,
+                 VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR, VK_PRESENT_MODE_FIFO_RELAXED_KHR);
+#if defined(_WIN32)
+        if (!demo->suppress_popups) MessageBox(NULL, usage, "Usage Error", MB_OK);
+#else
+        fprintf(stderr, "%s", usage);
+        fflush(stderr);
+#endif
+        free(usage);
+        exit(1);
+#endif
+    }
+
+    demo->initialized = false;
+
+    demo_init_vk(demo);
+
+    demo->spin_angle = 4.0f;
+    demo->spin_increment = 0.2f;
+    demo->pause = false;
+
+    mat4x4_perspective(demo->projection_matrix, (float)degreesToRadians(45.0f), 1.0f, 0.1f, 100.0f);
+    mat4x4_look_at(demo->view_matrix, eye, origin, up);
+    mat4x4_identity(demo->model_matrix);
+
+    demo->projection_matrix[1][1] *= -1;  // Flip projection matrix from GL to Vulkan orientation.
+}
+
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+// Include header required for parsing the command line options.
+#include <shellapi.h>
+
+int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR pCmdLine, int nCmdShow) {
+    MSG msg;    // message
+    bool done;  // flag saying when app is complete
+    int argc;
+    char **argv;
+
+    // Ensure wParam is initialized.
+    msg.wParam = 0;
+
+    // Use the CommandLine functions to get the command line arguments.
+    // Unfortunately, Microsoft outputs
+    // this information as wide characters for Unicode, and we simply want the
+    // Ascii version to be compatible
+    // with the non-Windows side.  So, we have to convert the information to
+    // Ascii character strings.
+    LPWSTR *commandLineArgs = CommandLineToArgvW(GetCommandLineW(), &argc);
+    if (NULL == commandLineArgs) {
+        argc = 0;
+    }
+
+    if (argc > 0) {
+        argv = (char **)malloc(sizeof(char *) * argc);
+        if (argv == NULL) {
+            argc = 0;
+        } else {
+            for (int iii = 0; iii < argc; iii++) {
+                size_t wideCharLen = wcslen(commandLineArgs[iii]);
+                size_t numConverted = 0;
+
+                argv[iii] = (char *)malloc(sizeof(char) * (wideCharLen + 1));
+                if (argv[iii] != NULL) {
+                    wcstombs_s(&numConverted, argv[iii], wideCharLen + 1, commandLineArgs[iii], wideCharLen + 1);
+                }
+            }
+        }
+    } else {
+        argv = NULL;
+    }
+
+    demo_init(&demo, argc, argv);
+
+    // Free up the items we had to allocate for the command line arguments.
+    if (argc > 0 && argv != NULL) {
+        for (int iii = 0; iii < argc; iii++) {
+            if (argv[iii] != NULL) {
+                free(argv[iii]);
+            }
+        }
+        free(argv);
+    }
+
+    demo.connection = hInstance;
+    strncpy(demo.name, "Vulkan Cube", APP_NAME_STR_LEN);
+    demo_create_window(&demo);
+    demo_create_surface(&demo);
+    demo_select_physical_device(&demo);
+    demo_init_vk_swapchain(&demo);
+
+    demo_prepare(&demo);
+
+    done = false;  // initialize loop condition variable
+
+    // main message loop
+    while (!done) {
+        if (demo.pause) {
+            const BOOL succ = WaitMessage();
+
+            if (!succ) {
+                struct demo *tmp = &demo;
+                struct demo *demo = tmp;
+                ERR_EXIT("WaitMessage() failed on paused demo", "event loop error");
+            }
+        }
+        PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
+        if (msg.message == WM_QUIT)  // check for a quit message
+        {
+            done = true;  // if found, quit app
+        } else {
+            /* Translate and dispatch to event queue*/
+            TranslateMessage(&msg);
+            DispatchMessage(&msg);
+        }
+        RedrawWindow(demo.window, NULL, NULL, RDW_INTERNALPAINT);
+    }
+
+    demo_cleanup(&demo);
+
+    return (int)msg.wParam;
+}
+
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+static void demo_main(struct demo *demo, void *caMetalLayer, int argc, const char *argv[]) {
+    demo_init(demo, argc, (char **)argv);
+    demo->caMetalLayer = caMetalLayer;
+    demo_create_surface(demo);
+    demo_select_physical_device(demo);
+    demo_init_vk_swapchain(demo);
+    demo_prepare(demo);
+    demo->spin_angle = 0.4f;
+}
+
+#endif
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+#include <android/log.h>
+#include <android_native_app_glue.h>
+#include "android_util.h"
+
+static bool active = false;
+struct demo demo;
+
+static int32_t processInput(struct android_app *app, AInputEvent *event) { return 0; }
+
+static void processCommand(struct android_app *app, int32_t cmd) {
+    switch (cmd) {
+        case APP_CMD_INIT_WINDOW: {
+            if (app->window) {
+                // We're getting a new window.  If the app is starting up, we
+                // need to initialize.  If the app has already been
+                // initialized, that means that we lost our previous window,
+                // which means that we have a lot of work to do.  At a minimum,
+                // we need to destroy the swapchain and surface associated with
+                // the old window, and create a new surface and swapchain.
+                // However, since there are a lot of other objects/state that
+                // is tied to the swapchain, it's easiest to simply cleanup and
+                // start over (i.e. use a brute-force approach of re-starting
+                // the app)
+                if (demo.initialized) {
+                    demo_cleanup(&demo);
+                }
+
+                // Parse Intents into argc, argv
+                // Use the following key to send arguments, i.e.
+                // --es args "--validate"
+                const char key[] = "args";
+                char *appTag = (char *)APP_SHORT_NAME;
+                int argc = 0;
+                char **argv = get_args(app, key, appTag, &argc);
+
+                __android_log_print(ANDROID_LOG_INFO, appTag, "argc = %i", argc);
+                for (int i = 0; i < argc; i++) __android_log_print(ANDROID_LOG_INFO, appTag, "argv[%i] = %s", i, argv[i]);
+
+                demo_init(&demo, argc, argv);
+
+                // Free the argv malloc'd by get_args
+                for (int i = 0; i < argc; i++) free(argv[i]);
+
+                demo.window = (void *)app->window;
+                demo_create_surface(&demo);
+                demo_select_physical_device(&demo);
+                demo_init_vk_swapchain(&demo);
+                demo_prepare(&demo);
+            }
+            break;
+        }
+        case APP_CMD_GAINED_FOCUS: {
+            active = true;
+            break;
+        }
+        case APP_CMD_LOST_FOCUS: {
+            active = false;
+            break;
+        }
+    }
+}
+
+void android_main(struct android_app *app) {
+    demo.initialized = false;
+
+    app->onAppCmd = processCommand;
+    app->onInputEvent = processInput;
+
+    while (1) {
+        int events;
+        struct android_poll_source *source;
+        while (ALooper_pollOnce(active ? 0 : -1, NULL, &events, (void **)&source) >= 0) {
+            if (source) {
+                source->process(app, source);
+            }
+
+            if (app->destroyRequested != 0) {
+                demo_cleanup(&demo);
+                return;
+            }
+        }
+        if (demo.initialized && demo.swapchain_ready && active) {
+            demo_run(&demo);
+        }
+    }
+}
+#elif defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__QNX__) || defined(__GNU__)
+int main(int argc, char **argv) {
+    struct demo demo;
+
+    demo_init(&demo, argc, argv);
+    switch (demo.wsi_platform) {
+        default:
+        case (WSI_PLATFORM_AUTO):
+            fprintf(stderr,
+                    "WSI platform should have already been set, indicating a bug. Please set a WSI platform manually with "
+                    "--wsi\n");
+            exit(1);
+            break;
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+        case (WSI_PLATFORM_XCB):
+            demo_create_xcb_window(&demo);
+            break;
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+        case (WSI_PLATFORM_XLIB):
+            demo_create_xlib_window(&demo);
+            break;
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+        case (WSI_PLATFORM_WAYLAND):
+            demo_create_wayland_window(&demo);
+            break;
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+        case (WSI_PLATFORM_DIRECTFB):
+            demo_create_directfb_window(&demo);
+            break;
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+        case (WSI_PLATFORM_QNX):
+            demo_create_screen_window(&demo);
+            break;
+#endif
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+        case (WSI_PLATFORM_DISPLAY):
+            // select physical device because display surface creation needs a gpu to be selected.
+            demo_select_physical_device(&demo);
+            break;
+#endif
+    }
+    demo_create_surface(&demo);
+    if (demo.wsi_platform != WSI_PLATFORM_DISPLAY) {
+        demo_select_physical_device(&demo);
+    }
+
+    demo_init_vk_swapchain(&demo);
+
+    demo_prepare(&demo);
+
+    switch (demo.wsi_platform) {
+        default:
+        case (WSI_PLATFORM_AUTO):
+            fprintf(stderr,
+                    "WSI platform should have already been set, indicating a bug. Please set a WSI platform manually with "
+                    "--wsi\n");
+            exit(1);
+            break;
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+        case (WSI_PLATFORM_XCB):
+            demo_run_xcb(&demo);
+            break;
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+        case (WSI_PLATFORM_XLIB):
+            demo_run_xlib(&demo);
+            break;
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+        case (WSI_PLATFORM_WAYLAND):
+            demo_run(&demo);
+            break;
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+        case (WSI_PLATFORM_DIRECTFB):
+            demo_run_directfb(&demo);
+            break;
+#endif
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+        case (WSI_PLATFORM_DISPLAY):
+            demo_run_display(&demo);
+            break;
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+        case (WSI_PLATFORM_QNX):
+            demo_run(&demo);
+            break;
+#endif
+    }
+
+    demo_cleanup(&demo);
+
+    return validation_error;
+}
+#endif
diff --git a/tools/Vulkan-Tools/cube/cube.cpp b/tools/Vulkan-Tools/cube/cube.cpp
new file mode 100644
index 00000000..de411cfa
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/cube.cpp
@@ -0,0 +1,4252 @@
+/*
+ * Copyright (c) 2015-2019 The Khronos Group Inc.
+ * Copyright (c) 2015-2019 Valve Corporation
+ * Copyright (c) 2015-2019 LunarG, Inc.
+ * Copyright (c) 2025 The Fuchsia Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Jeremy Hayes <jeremy@lunarg.com>
+ * Author: Charles Giessen <charles@lunarg.com>
+ */
+
+#include <algorithm>
+#include <cassert>
+#include <cinttypes>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <csignal>
+
+#include <sstream>
+#include <iostream>
+#include <memory>
+#include <map>
+
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+#include "xlib_loader.h"
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+#include "xcb_loader.h"
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+#include <linux/input.h>
+#include "wayland_loader.h"
+#endif
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+#include <fidl/fuchsia.ui.app/cpp/fidl.h>
+#include <lib/async-loop/cpp/loop.h>
+#include <lib/component/incoming/cpp/protocol.h>
+#include <lib/component/outgoing/cpp/outgoing_directory.h>
+#include <lib/zx/result.h>
+
+#include "fuchsia/flatland_view.h"
+#endif
+
+#define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1
+#define VULKAN_HPP_NO_EXCEPTIONS
+#define VULKAN_HPP_TYPESAFE_CONVERSION 1
+
+#include <vulkan/vulkan.hpp>
+
+VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
+
+#include "linmath.h"
+
+#ifndef NDEBUG
+#define VERIFY(x) assert(x)
+#else
+#define VERIFY(x) ((void)(x))
+#endif
+
+#define APP_SHORT_NAME "vkcubepp"
+
+// Allow a maximum of two outstanding presentation operations.
+constexpr uint32_t FRAME_LAG = 2;
+
+#ifdef _WIN32
+#define ERR_EXIT(err_msg, err_class)                                          \
+    do {                                                                      \
+        if (!suppress_popups) MessageBox(nullptr, err_msg, err_class, MB_OK); \
+        exit(1);                                                              \
+    } while (0)
+#else
+#define ERR_EXIT(err_msg, err_class) \
+    do {                             \
+        printf("%s\n", err_msg);     \
+        fflush(stdout);              \
+        exit(1);                     \
+    } while (0)
+#endif
+
+struct texture_object {
+    vk::Sampler sampler;
+
+    vk::Image image;
+    vk::Buffer buffer;
+    vk::ImageLayout imageLayout{vk::ImageLayout::eUndefined};
+
+    vk::MemoryAllocateInfo mem_alloc;
+    vk::DeviceMemory mem;
+    vk::ImageView view;
+
+    uint32_t tex_width{0};
+    uint32_t tex_height{0};
+};
+
+static char const *const tex_files[] = {"lunarg.ppm"};
+
+static int validation_error = 0;
+
+struct vktexcube_vs_uniform {
+    // Must start with MVP
+    float mvp[4][4];
+    float position[12 * 3][4];
+    float attr[12 * 3][4];
+};
+
+//--------------------------------------------------------------------------------------
+// Mesh and VertexFormat Data
+//--------------------------------------------------------------------------------------
+// clang-format off
+static const float g_vertex_buffer_data[] = {
+    -1.0f,-1.0f,-1.0f,  // -X side
+    -1.0f,-1.0f, 1.0f,
+    -1.0f, 1.0f, 1.0f,
+    -1.0f, 1.0f, 1.0f,
+    -1.0f, 1.0f,-1.0f,
+    -1.0f,-1.0f,-1.0f,
+
+    -1.0f,-1.0f,-1.0f,  // -Z side
+     1.0f, 1.0f,-1.0f,
+     1.0f,-1.0f,-1.0f,
+    -1.0f,-1.0f,-1.0f,
+    -1.0f, 1.0f,-1.0f,
+     1.0f, 1.0f,-1.0f,
+
+    -1.0f,-1.0f,-1.0f,  // -Y side
+     1.0f,-1.0f,-1.0f,
+     1.0f,-1.0f, 1.0f,
+    -1.0f,-1.0f,-1.0f,
+     1.0f,-1.0f, 1.0f,
+    -1.0f,-1.0f, 1.0f,
+
+    -1.0f, 1.0f,-1.0f,  // +Y side
+    -1.0f, 1.0f, 1.0f,
+     1.0f, 1.0f, 1.0f,
+    -1.0f, 1.0f,-1.0f,
+     1.0f, 1.0f, 1.0f,
+     1.0f, 1.0f,-1.0f,
+
+     1.0f, 1.0f,-1.0f,  // +X side
+     1.0f, 1.0f, 1.0f,
+     1.0f,-1.0f, 1.0f,
+     1.0f,-1.0f, 1.0f,
+     1.0f,-1.0f,-1.0f,
+     1.0f, 1.0f,-1.0f,
+
+    -1.0f, 1.0f, 1.0f,  // +Z side
+    -1.0f,-1.0f, 1.0f,
+     1.0f, 1.0f, 1.0f,
+    -1.0f,-1.0f, 1.0f,
+     1.0f,-1.0f, 1.0f,
+     1.0f, 1.0f, 1.0f,
+};
+
+static const float g_uv_buffer_data[] = {
+    0.0f, 1.0f,  // -X side
+    1.0f, 1.0f,
+    1.0f, 0.0f,
+    1.0f, 0.0f,
+    0.0f, 0.0f,
+    0.0f, 1.0f,
+
+    1.0f, 1.0f,  // -Z side
+    0.0f, 0.0f,
+    0.0f, 1.0f,
+    1.0f, 1.0f,
+    1.0f, 0.0f,
+    0.0f, 0.0f,
+
+    1.0f, 0.0f,  // -Y side
+    1.0f, 1.0f,
+    0.0f, 1.0f,
+    1.0f, 0.0f,
+    0.0f, 1.0f,
+    0.0f, 0.0f,
+
+    1.0f, 0.0f,  // +Y side
+    0.0f, 0.0f,
+    0.0f, 1.0f,
+    1.0f, 0.0f,
+    0.0f, 1.0f,
+    1.0f, 1.0f,
+
+    1.0f, 0.0f,  // +X side
+    0.0f, 0.0f,
+    0.0f, 1.0f,
+    0.0f, 1.0f,
+    1.0f, 1.0f,
+    1.0f, 0.0f,
+
+    0.0f, 0.0f,  // +Z side
+    0.0f, 1.0f,
+    1.0f, 0.0f,
+    0.0f, 1.0f,
+    1.0f, 1.0f,
+    1.0f, 0.0f,
+};
+// clang-format on
+enum class WsiPlatform {
+    auto_ = 0,
+    win32,
+    metal,
+    android,
+    qnx,
+    xcb,
+    xlib,
+    wayland,
+    directfb,
+    display,
+    fuchsia_display,
+    fuchsia_scenic,
+    invalid,  // Sentinel just to indicate invalid user input
+};
+
+WsiPlatform wsi_from_string(std::string const &str) {
+    if (str == "auto") return WsiPlatform::auto_;
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+    if (str == "win32") return WsiPlatform::win32;
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+    if (str == "metal") return WsiPlatform::metal;
+#endif
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+    if (str == "android") return WsiPlatform::android;
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+    if (str == "qnx") return WsiPlatform::qnx;
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+    if (str == "xcb") return WsiPlatform::xcb;
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+    if (str == "xlib") return WsiPlatform::xlib;
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+    if (str == "wayland") return WsiPlatform::wayland;
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+    if (str == "directfb") return WsiPlatform::directfb;
+#endif
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+    if (str == "display") return WsiPlatform::display;
+#endif
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+    if (str == "fuchsia_display") return WsiPlatform::fuchsia_display;
+    if (str == "fuchsia_scenic") return WsiPlatform::fuchsia_scenic;
+#endif
+    return WsiPlatform::invalid;
+};
+
+const char *wsi_to_string(WsiPlatform wsi_platform) {
+    switch (wsi_platform) {
+        case (WsiPlatform::auto_):
+            return "auto";
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+        case (WsiPlatform::win32):
+            return "win32";
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+        case (WsiPlatform::metal):
+            return "metal";
+#endif
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+        case (WsiPlatform::android):
+            return "android";
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+        case (WsiPlatform::qnx):
+            return "qnx";
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+        case (WsiPlatform::xcb):
+            return "xcb";
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+        case (WsiPlatform::xlib):
+            return "xlib";
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+        case (WsiPlatform::wayland):
+            return "wayland";
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+        case (WsiPlatform::directfb):
+            return "directfb";
+#endif
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+        case (WsiPlatform::display):
+            return "display";
+#endif
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+        case (WsiPlatform::fuchsia_display):
+            return "fuchsia_display";
+        case (WsiPlatform::fuchsia_scenic):
+            return "fuchsia_scenic";
+#endif
+        default:
+            return "unknown";
+    }
+};
+
+struct SubmissionResources {
+    vk::Fence fence;
+    vk::Semaphore image_acquired_semaphore;
+    vk::CommandBuffer cmd;
+    vk::CommandBuffer graphics_to_present_cmd;
+    vk::Buffer uniform_buffer;
+    vk::DeviceMemory uniform_memory;
+    void *uniform_memory_ptr = nullptr;
+    vk::DescriptorSet descriptor_set;
+};
+
+struct SwapchainImageResources {
+    vk::Image image;
+    vk::ImageView view;
+    vk::Framebuffer framebuffer;
+    vk::Semaphore draw_complete_semaphore;
+    vk::Semaphore image_ownership_semaphore;
+};
+
+struct Demo {
+    void build_image_ownership_cmd(const SubmissionResources &submission_resource,
+                                   const SwapchainImageResources &swapchain_image_resource);
+    vk::Bool32 check_layers(const std::vector<const char *> &check_names, const std::vector<vk::LayerProperties> &layers);
+    void cleanup();
+    void create_device();
+    void destroy_texture(texture_object &tex_objs);
+    void draw();
+    void draw_build_cmd(const SubmissionResources &submission_resource, const SwapchainImageResources &swapchain_image_resource);
+    void prepare_init_cmd();
+    void flush_init_cmd();
+    void init(int argc, char **argv);
+    void check_and_set_wsi_platform();
+    void init_vk();
+    void select_physical_device();
+    void init_vk_swapchain();
+
+    void prepare();
+    void prepare_cube_data_buffers();
+    void prepare_descriptor_layout();
+    void prepare_descriptor_pool();
+    void prepare_descriptor_set();
+    void prepare_submission_sync_objects();
+    vk::ShaderModule prepare_shader_module(const uint32_t *code, size_t size);
+    vk::ShaderModule prepare_vs();
+    vk::ShaderModule prepare_fs();
+    void prepare_pipeline();
+    void prepare_render_pass();
+    void prepare_texture_image(const char *filename, texture_object &tex_obj, vk::ImageTiling tiling, vk::ImageUsageFlags usage,
+                               vk::MemoryPropertyFlags required_props);
+    void prepare_texture_buffer(const char *filename, texture_object &tex_obj);
+    void prepare_textures();
+
+    void resize();
+    void create_surface();
+    void prepare_swapchain();
+    void prepare_framebuffers();
+    void prepare_depth();
+
+    void set_image_layout(vk::Image image, vk::ImageAspectFlags aspectMask, vk::ImageLayout oldLayout, vk::ImageLayout newLayout,
+                          vk::AccessFlags srcAccessMask, vk::PipelineStageFlags src_stages, vk::PipelineStageFlags dest_stages);
+    void update_data_buffer(void *uniform_memory_ptr);
+    bool loadTexture(const char *filename, uint8_t *rgba_data, vk::SubresourceLayout &layout, uint32_t &width, uint32_t &height);
+    bool memory_type_from_properties(uint32_t typeBits, vk::MemoryPropertyFlags requirements_mask, uint32_t &typeIndex);
+    vk::SurfaceFormatKHR pick_surface_format(const std::vector<vk::SurfaceFormatKHR> &surface_formats);
+
+    static VKAPI_ATTR vk::Bool32 VKAPI_CALL debug_messenger_callback(vk::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+                                                                     vk::DebugUtilsMessageTypeFlagsEXT messageType,
+                                                                     const vk::DebugUtilsMessengerCallbackDataEXT *pCallbackData,
+                                                                     void *pUserData);
+
+    template <WsiPlatform WSI_PLATFORM>
+    void create_window() = delete;
+    template <WsiPlatform WSI_PLATFORM>
+    void run() = delete;
+    template <WsiPlatform WSI_PLATFORM>
+    void execute();
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+    const char *init_xlib_connection();
+    void handle_xlib_event(const XEvent *event);
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+    const char *init_xcb_connection();
+    void handle_xcb_event(const xcb_generic_event_t *event);
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+    const char *init_wayland_connection();
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+    void handle_directfb_event(const DFBInputEvent *event);
+#endif
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+    vk::Result create_display_surface();
+#endif
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+    // Returns a layer name of static storage duration.
+    const char *get_fuchsia_image_pipe_layer() const;
+#endif
+
+    std::string name = "vkcubepp";  // Name to put on the window/icon
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+    HINSTANCE connection = nullptr;  // hInstance - Windows Instance
+    HWND window = nullptr;           // hWnd - window handle
+    POINT minsize = {0, 0};          // minimum window size
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+    void *xlib_library;
+    Window xlib_window = 0;
+    Atom xlib_wm_delete_window = 0;
+    Display *xlib_display = nullptr;
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+    void *xcb_library;
+    xcb_window_t xcb_window = 0;
+    xcb_screen_t *screen = nullptr;
+    xcb_connection_t *connection = nullptr;
+    xcb_intern_atom_reply_t *atom_wm_delete_window = nullptr;
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+    void *wayland_library = nullptr;
+    wl_display *wayland_display = nullptr;
+    wl_registry *registry = nullptr;
+    wl_compositor *compositor = nullptr;
+    wl_surface *wayland_window = nullptr;
+    xdg_wm_base *wm_base = nullptr;
+    zxdg_decoration_manager_v1 *xdg_decoration_mgr = nullptr;
+    zxdg_toplevel_decoration_v1 *toplevel_decoration = nullptr;
+    xdg_surface *window_surface = nullptr;
+    bool xdg_surface_has_been_configured = false;
+    xdg_toplevel *window_toplevel = nullptr;
+    wl_seat *seat = nullptr;
+    wl_pointer *pointer = nullptr;
+    wl_keyboard *keyboard = nullptr;
+    int pending_width = 0, pending_height = 0;
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+    IDirectFB *dfb = nullptr;
+    IDirectFBSurface *directfb_window = nullptr;
+    IDirectFBEventBuffer *event_buffer = nullptr;
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+    void *caMetalLayer;
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+    screen_context_t screen_context = nullptr;
+    screen_window_t screen_window = nullptr;
+    screen_event_t screen_event = nullptr;
+#endif
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+    fuchsia_ui_views::ViewCreationToken view_creation_token;
+    async::Loop loop{&kAsyncLoopConfigNeverAttachToThread};
+    fidl::ClientEnd<fuchsia_io::Directory> incoming;
+    std::unique_ptr<component::OutgoingDirectory> outgoing;
+    std::unique_ptr<FlatlandViewProviderService> view_provider_service;
+    std::unique_ptr<FlatlandView> flatland_view;
+#endif
+    WsiPlatform wsi_platform = WsiPlatform::auto_;
+    vk::SurfaceKHR surface;
+    bool initialized;
+    bool swapchain_ready;
+    bool is_minimized;
+    bool use_staging_buffer = false;
+    bool separate_present_queue = false;
+    bool invalid_gpu_selection = false;
+    int32_t gpu_number = 0;
+
+    // If true, the Demo renders on the protected memory. This requires the
+    // physical device to support protected memory.
+    bool protected_output = false;
+
+    vk::Instance inst;
+    vk::DebugUtilsMessengerEXT debug_messenger;
+    vk::PhysicalDevice gpu;
+    vk::Device device;
+    vk::Queue graphics_queue;
+    vk::Queue present_queue;
+    uint32_t graphics_queue_family_index = 0;
+    uint32_t present_queue_family_index = 0;
+    vk::PhysicalDeviceProperties gpu_props;
+    std::vector<vk::QueueFamilyProperties> queue_props;
+    vk::PhysicalDeviceMemoryProperties memory_properties;
+    std::array<SubmissionResources, FRAME_LAG> submission_resources;
+    uint32_t current_submission_index = 0;
+
+    std::vector<const char *> enabled_instance_extensions;
+    std::vector<const char *> enabled_layers;
+    std::vector<const char *> enabled_device_extensions;
+
+    uint32_t width = 0;
+    uint32_t height = 0;
+    vk::Format format;
+    vk::ColorSpaceKHR color_space;
+
+    vk::SwapchainKHR swapchain;
+    std::vector<SwapchainImageResources> swapchain_resources;
+    vk::PresentModeKHR presentMode = vk::PresentModeKHR::eFifo;
+    bool first_swapchain_frame;
+
+    vk::CommandPool cmd_pool;
+    vk::CommandPool present_cmd_pool;
+
+    struct {
+        vk::Format format;
+        vk::Image image;
+        vk::MemoryAllocateInfo mem_alloc;
+        vk::DeviceMemory mem;
+        vk::ImageView view;
+    } depth;
+
+    static int32_t const texture_count = 1;
+    std::array<texture_object, texture_count> textures;
+    texture_object staging_texture;
+
+    struct {
+        vk::Buffer buf;
+        vk::MemoryAllocateInfo mem_alloc;
+        vk::DeviceMemory mem;
+        vk::DescriptorBufferInfo buffer_info;
+    } uniform_data;
+
+    vk::CommandBuffer cmd;  // Buffer for initialization commands
+    vk::PipelineLayout pipeline_layout;
+    vk::DescriptorSetLayout desc_layout;
+    vk::PipelineCache pipelineCache;
+    vk::RenderPass render_pass;
+    vk::Pipeline pipeline;
+
+    mat4x4 projection_matrix = {};
+    mat4x4 view_matrix = {};
+    mat4x4 model_matrix = {};
+
+    float spin_angle = 0.0f;
+    float spin_increment = 0.0f;
+    bool pause = false;
+
+    vk::ShaderModule vert_shader_module;
+    vk::ShaderModule frag_shader_module;
+
+    vk::DescriptorPool desc_pool;
+    vk::DescriptorSet desc_set;
+
+    std::vector<vk::Framebuffer> framebuffers;
+
+    bool quit = false;
+    uint32_t curFrame = 0;
+    uint32_t frameCount = 0;
+    bool validate = false;
+    bool in_callback = false;
+    bool use_debug_messenger = false;
+    bool use_break = false;
+    bool suppress_popups = false;
+    bool force_errors = false;
+};
+
+#ifdef _WIN32
+// MS-Windows event handling function:
+LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
+#endif
+
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+static void pointer_handle_enter(void *data, struct wl_pointer *pointer, uint32_t serial, struct wl_surface *surface, wl_fixed_t sx,
+                                 wl_fixed_t sy) {}
+
+static void pointer_handle_leave(void *data, struct wl_pointer *pointer, uint32_t serial, struct wl_surface *surface) {}
+
+static void pointer_handle_motion(void *data, struct wl_pointer *pointer, uint32_t time, wl_fixed_t sx, wl_fixed_t sy) {}
+
+static void pointer_handle_button(void *data, struct wl_pointer *wl_pointer, uint32_t serial, uint32_t time, uint32_t button,
+                                  uint32_t state) {
+    Demo &demo = *static_cast<Demo *>(data);
+    if (button == BTN_LEFT && state == WL_POINTER_BUTTON_STATE_PRESSED) {
+        xdg_toplevel_move(demo.window_toplevel, demo.seat, serial);
+    }
+}
+
+static void pointer_handle_axis(void *data, struct wl_pointer *wl_pointer, uint32_t time, uint32_t axis, wl_fixed_t value) {}
+
+static const struct wl_pointer_listener pointer_listener = {
+    pointer_handle_enter, pointer_handle_leave, pointer_handle_motion, pointer_handle_button, pointer_handle_axis,
+};
+
+static void keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard, uint32_t format, int fd, uint32_t size) {}
+
+static void keyboard_handle_enter(void *data, struct wl_keyboard *keyboard, uint32_t serial, struct wl_surface *surface,
+                                  struct wl_array *keys) {}
+
+static void keyboard_handle_leave(void *data, struct wl_keyboard *keyboard, uint32_t serial, struct wl_surface *surface) {}
+
+static void keyboard_handle_key(void *data, struct wl_keyboard *keyboard, uint32_t serial, uint32_t time, uint32_t key,
+                                uint32_t state) {
+    if (state != WL_KEYBOARD_KEY_STATE_RELEASED) return;
+    Demo &demo = *static_cast<Demo *>(data);
+    switch (key) {
+        case KEY_ESC:  // Escape
+            demo.quit = true;
+            break;
+        case KEY_LEFT:  // left arrow key
+            demo.spin_angle -= demo.spin_increment;
+            break;
+        case KEY_RIGHT:  // right arrow key
+            demo.spin_angle += demo.spin_increment;
+            break;
+        case KEY_SPACE:  // space bar
+            demo.pause = !demo.pause;
+            break;
+    }
+}
+
+static void keyboard_handle_modifiers(void *data, wl_keyboard *keyboard, uint32_t serial, uint32_t mods_depressed,
+                                      uint32_t mods_latched, uint32_t mods_locked, uint32_t group) {}
+
+static const struct wl_keyboard_listener keyboard_listener = {
+    keyboard_handle_keymap, keyboard_handle_enter, keyboard_handle_leave, keyboard_handle_key, keyboard_handle_modifiers,
+};
+
+static void seat_handle_capabilities(void *data, wl_seat *seat, uint32_t caps) {
+    // Subscribe to pointer events
+    Demo &demo = *static_cast<Demo *>(data);
+    if ((caps & WL_SEAT_CAPABILITY_POINTER) && !demo.pointer) {
+        demo.pointer = wl_seat_get_pointer(seat);
+        wl_pointer_add_listener(demo.pointer, &pointer_listener, &demo);
+    } else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && demo.pointer) {
+        wl_pointer_destroy(demo.pointer);
+        demo.pointer = nullptr;
+    }
+    // Subscribe to keyboard events
+    if (caps & WL_SEAT_CAPABILITY_KEYBOARD) {
+        demo.keyboard = wl_seat_get_keyboard(seat);
+        wl_keyboard_add_listener(demo.keyboard, &keyboard_listener, &demo);
+    } else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && demo.keyboard) {
+        wl_keyboard_destroy(demo.keyboard);
+        demo.keyboard = nullptr;
+    }
+}
+
+static const wl_seat_listener seat_listener = {
+    seat_handle_capabilities,
+};
+
+static void wm_base_ping(void *data, xdg_wm_base *xdg_wm_base, uint32_t serial) { xdg_wm_base_pong(xdg_wm_base, serial); }
+
+static const struct xdg_wm_base_listener wm_base_listener = {wm_base_ping};
+
+static void registry_handle_global(void *data, wl_registry *registry, uint32_t id, const char *interface, uint32_t version) {
+    Demo &demo = *static_cast<Demo *>(data);
+    // pickup wayland objects when they appear
+    if (strcmp(interface, wl_compositor_interface.name) == 0) {
+        demo.compositor = (wl_compositor *)wl_registry_bind(registry, id, &wl_compositor_interface, 1);
+    } else if (strcmp(interface, xdg_wm_base_interface.name) == 0) {
+        demo.wm_base = (xdg_wm_base *)wl_registry_bind(registry, id, &xdg_wm_base_interface, 1);
+        xdg_wm_base_add_listener(demo.wm_base, &wm_base_listener, nullptr);
+    } else if (strcmp(interface, wl_seat_interface.name) == 0) {
+        demo.seat = (wl_seat *)wl_registry_bind(registry, id, &wl_seat_interface, 1);
+        wl_seat_add_listener(demo.seat, &seat_listener, &demo);
+    } else if (strcmp(interface, zxdg_decoration_manager_v1_interface.name) == 0) {
+        demo.xdg_decoration_mgr =
+            (zxdg_decoration_manager_v1 *)wl_registry_bind(registry, id, &zxdg_decoration_manager_v1_interface, 1);
+    }
+}
+
+static void registry_handle_global_remove(void *data, wl_registry *registry, uint32_t name) {}
+
+static const wl_registry_listener registry_listener = {registry_handle_global, registry_handle_global_remove};
+#endif
+
+void Demo::build_image_ownership_cmd(const SubmissionResources &submission_resource,
+                                     const SwapchainImageResources &swapchain_image_resource) {
+    auto result = submission_resource.graphics_to_present_cmd.reset();
+    VERIFY(result == vk::Result::eSuccess);
+
+    result = submission_resource.graphics_to_present_cmd.begin(
+        vk::CommandBufferBeginInfo().setFlags(vk::CommandBufferUsageFlagBits::eSimultaneousUse));
+    VERIFY(result == vk::Result::eSuccess);
+
+    auto const image_ownership_barrier =
+        vk::ImageMemoryBarrier()
+            .setSrcAccessMask(vk::AccessFlags())
+            .setDstAccessMask(vk::AccessFlags())
+            .setOldLayout(vk::ImageLayout::ePresentSrcKHR)
+            .setNewLayout(vk::ImageLayout::ePresentSrcKHR)
+            .setSrcQueueFamilyIndex(graphics_queue_family_index)
+            .setDstQueueFamilyIndex(present_queue_family_index)
+            .setImage(swapchain_image_resource.image)
+            .setSubresourceRange(vk::ImageSubresourceRange(vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1));
+
+    submission_resource.graphics_to_present_cmd.pipelineBarrier(vk::PipelineStageFlagBits::eBottomOfPipe,
+                                                                vk::PipelineStageFlagBits::eBottomOfPipe, vk::DependencyFlagBits(),
+                                                                {}, {}, image_ownership_barrier);
+
+    result = submission_resource.graphics_to_present_cmd.end();
+    VERIFY(result == vk::Result::eSuccess);
+}
+
+vk::Bool32 Demo::check_layers(const std::vector<const char *> &check_names, const std::vector<vk::LayerProperties> &layers) {
+    for (const auto &name : check_names) {
+        vk::Bool32 found = VK_FALSE;
+        for (const auto &layer : layers) {
+            if (!strcmp(name, layer.layerName)) {
+                found = VK_TRUE;
+                break;
+            }
+        }
+        if (!found) {
+            fprintf(stderr, "Cannot find layer: %s\n", name);
+            return 0;
+        }
+    }
+    return VK_TRUE;
+}
+
+void Demo::cleanup() {
+    initialized = false;
+    auto result = device.waitIdle();
+    VERIFY(result == vk::Result::eSuccess);
+
+    device.destroyCommandPool(cmd_pool);
+    if (separate_present_queue) {
+        device.destroyCommandPool(present_cmd_pool);
+    }
+
+    device.destroyDescriptorPool(desc_pool);
+
+    device.destroyPipeline(pipeline);
+    device.destroyPipelineCache(pipelineCache);
+    device.destroyRenderPass(render_pass);
+    device.destroyPipelineLayout(pipeline_layout);
+    device.destroyDescriptorSetLayout(desc_layout);
+
+    for (const auto &tex : textures) {
+        device.destroyImageView(tex.view);
+        device.destroyImage(tex.image);
+        device.freeMemory(tex.mem);
+        device.destroySampler(tex.sampler);
+    }
+
+    device.destroyImageView(depth.view);
+    device.destroyImage(depth.image);
+    device.freeMemory(depth.mem);
+
+    for (auto &swapchain_resource : swapchain_resources) {
+        device.destroyFramebuffer(swapchain_resource.framebuffer);
+        device.destroyImageView(swapchain_resource.view);
+        device.destroySemaphore(swapchain_resource.draw_complete_semaphore);
+        if (separate_present_queue) {
+            device.destroySemaphore(swapchain_resource.image_ownership_semaphore);
+        }
+    }
+
+    device.destroySwapchainKHR(swapchain);
+
+    for (const auto &submission_resource : submission_resources) {
+        device.destroyFence(submission_resource.fence);
+        device.destroySemaphore(submission_resource.image_acquired_semaphore);
+        device.destroyBuffer(submission_resource.uniform_buffer);
+        device.unmapMemory(submission_resource.uniform_memory);
+        device.freeMemory(submission_resource.uniform_memory);
+    }
+
+    device.destroy();
+    inst.destroySurfaceKHR(surface);
+
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+    if (wsi_platform == WsiPlatform::xlib) {
+        XDestroyWindow(xlib_display, xlib_window);
+        XCloseDisplay(xlib_display);
+    }
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+    if (wsi_platform == WsiPlatform::xcb) {
+        xcb_destroy_window(connection, xcb_window);
+        xcb_disconnect(connection);
+        free(atom_wm_delete_window);
+    }
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+    if (wsi_platform == WsiPlatform::wayland) {
+        if (keyboard) wl_keyboard_destroy(keyboard);
+        if (pointer) wl_pointer_destroy(pointer);
+        if (seat) wl_seat_destroy(seat);
+        xdg_toplevel_destroy(window_toplevel);
+        xdg_surface_destroy(window_surface);
+        wl_surface_destroy(wayland_window);
+        xdg_wm_base_destroy(wm_base);
+        if (xdg_decoration_mgr) {
+            zxdg_toplevel_decoration_v1_destroy(toplevel_decoration);
+            zxdg_decoration_manager_v1_destroy(xdg_decoration_mgr);
+        }
+        wl_compositor_destroy(compositor);
+        wl_registry_destroy(registry);
+        wl_display_disconnect(wayland_display);
+    }
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+    if (wsi_platform == WsiPlatform::directfb) {
+        event_buffer->Release(event_buffer);
+        directfb_window->Release(directfb_window);
+        dfb->Release(dfb);
+    }
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+    screen_destroy_event(screen_event);
+    screen_destroy_window(screen_window);
+    screen_destroy_context(screen_context);
+#endif
+    if (use_debug_messenger) {
+        inst.destroyDebugUtilsMessengerEXT(debug_messenger);
+    }
+    inst.destroy();
+}
+
+void Demo::create_device() {
+    float priorities = 0.0;
+
+    std::vector<vk::DeviceQueueCreateInfo> queues;
+    const vk::DeviceQueueCreateFlags queue_create_flags =
+        protected_output ? vk::DeviceQueueCreateFlagBits::eProtected : vk::DeviceQueueCreateFlags{};
+    queues.push_back(vk::DeviceQueueCreateInfo()
+                         .setQueueFamilyIndex(graphics_queue_family_index)
+                         .setQueuePriorities(priorities)
+                         .setFlags(queue_create_flags));
+
+    if (separate_present_queue) {
+        queues.push_back(
+            vk::DeviceQueueCreateInfo().setQueueFamilyIndex(present_queue_family_index).setQueuePriorities(priorities));
+    }
+
+    auto const protected_memory_features = vk::PhysicalDeviceProtectedMemoryFeatures().setProtectedMemory(protected_output);
+    auto deviceInfo = vk::DeviceCreateInfo()
+                          .setPNext(protected_output ? &protected_memory_features : nullptr)
+                          .setQueueCreateInfos(queues)
+                          .setPEnabledExtensionNames(enabled_device_extensions);
+    auto device_return = gpu.createDevice(deviceInfo);
+    VERIFY(device_return.result == vk::Result::eSuccess);
+    device = device_return.value;
+    VULKAN_HPP_DEFAULT_DISPATCHER.init(device);
+}
+
+void Demo::destroy_texture(texture_object &tex_objs) {
+    // clean up staging resources
+    device.freeMemory(tex_objs.mem);
+    if (tex_objs.image) device.destroyImage(tex_objs.image);
+    if (tex_objs.buffer) device.destroyBuffer(tex_objs.buffer);
+}
+
+void Demo::draw() {
+    // Don't draw if initialization isn't complete, if the swapchain became outdated, or if the window is minimized
+    if (!initialized || !swapchain_ready || is_minimized) {
+        return;
+    }
+
+    auto &current_submission = submission_resources[current_submission_index];
+
+    // Ensure no more than FRAME_LAG renderings are outstanding
+    const vk::Result wait_result = device.waitForFences(current_submission.fence, VK_TRUE, UINT64_MAX);
+    VERIFY(wait_result == vk::Result::eSuccess || wait_result == vk::Result::eTimeout);
+
+    vk::Result acquire_result;
+    uint32_t current_swapchain_image_index = 0;
+    do {
+        acquire_result = device.acquireNextImageKHR(swapchain, UINT64_MAX, current_submission.image_acquired_semaphore, vk::Fence(),
+                                                    &current_swapchain_image_index);
+        if (acquire_result == vk::Result::eErrorOutOfDateKHR) {
+            // demo.swapchain is out of date (e.g. the window was resized) and
+            // must be recreated:
+            resize();
+        } else if (acquire_result == vk::Result::eSuboptimalKHR) {
+            // swapchain is not as optimal as it could be, but the platform's
+            // presentation engine will still present the image correctly.
+            break;
+        } else if (acquire_result == vk::Result::eErrorSurfaceLostKHR) {
+            inst.destroySurfaceKHR(surface);
+            create_surface();
+            resize();
+        } else {
+            VERIFY(acquire_result == vk::Result::eSuccess);
+        }
+        // If we minimized then stop trying to draw
+        if (!swapchain_ready) {
+            return;
+        }
+    } while (acquire_result != vk::Result::eSuccess);
+
+    auto &current_swapchain_resource = swapchain_resources[current_swapchain_image_index];
+
+    update_data_buffer(submission_resources[current_submission_index].uniform_memory_ptr);
+
+    draw_build_cmd(current_submission, current_swapchain_resource);
+
+    if (separate_present_queue) {
+        build_image_ownership_cmd(current_submission, current_swapchain_resource);
+    }
+
+    // Only reset right before submitting so we can't deadlock on an un-signalled fence that has nothing submitted to it
+    auto reset_result = device.resetFences({current_submission.fence});
+    VERIFY(reset_result == vk::Result::eSuccess);
+
+    // Wait for the image acquired semaphore to be signaled to ensure
+    // that the image won't be rendered to until the presentation
+    // engine has fully released ownership to the application, and it is
+    // okay to render to the image.
+    vk::PipelineStageFlags const pipe_stage_flags = vk::PipelineStageFlagBits::eColorAttachmentOutput;
+    auto protected_submit_info = vk::ProtectedSubmitInfo().setProtectedSubmit(protected_output);
+
+    auto submit_result = graphics_queue.submit(vk::SubmitInfo()
+                                                   .setPNext(protected_output ? &protected_submit_info : nullptr)
+                                                   .setWaitDstStageMask(pipe_stage_flags)
+                                                   .setWaitSemaphores(current_submission.image_acquired_semaphore)
+                                                   .setCommandBuffers(current_submission.cmd)
+                                                   .setSignalSemaphores(current_swapchain_resource.draw_complete_semaphore),
+                                               current_submission.fence);
+    VERIFY(submit_result == vk::Result::eSuccess);
+
+    if (separate_present_queue) {
+        // If we are using separate queues, change image ownership to the
+        // present queue before presenting, waiting for the draw complete
+        // semaphore and signalling the ownership released semaphore when
+        // finished
+        auto change_owner_result =
+            present_queue.submit(vk::SubmitInfo()
+                                     .setWaitDstStageMask(pipe_stage_flags)
+                                     .setWaitSemaphores(current_swapchain_resource.draw_complete_semaphore)
+                                     .setCommandBuffers(current_submission.graphics_to_present_cmd)
+                                     .setSignalSemaphores(current_swapchain_resource.image_ownership_semaphore));
+        VERIFY(change_owner_result == vk::Result::eSuccess);
+    }
+
+    const auto presentInfo = vk::PresentInfoKHR()
+                                 .setWaitSemaphores(separate_present_queue ? current_swapchain_resource.image_ownership_semaphore
+                                                                           : current_swapchain_resource.draw_complete_semaphore)
+                                 .setSwapchains(swapchain)
+                                 .setImageIndices(current_swapchain_image_index);
+
+    // If we are using separate queues we have to wait for image ownership,
+    // otherwise wait for draw complete
+    auto present_result = present_queue.presentKHR(&presentInfo);
+    current_submission_index += 1;
+    current_submission_index %= FRAME_LAG;
+    first_swapchain_frame = false;
+    if (present_result == vk::Result::eErrorOutOfDateKHR) {
+        // swapchain is out of date (e.g. the window was resized) and
+        // must be recreated:
+        resize();
+    } else if (present_result == vk::Result::eSuboptimalKHR) {
+        // SUBOPTIMAL could be due to resize
+        vk::SurfaceCapabilitiesKHR surfCapabilities;
+        auto caps_result = gpu.getSurfaceCapabilitiesKHR(surface, &surfCapabilities);
+        VERIFY(caps_result == vk::Result::eSuccess);
+        if (surfCapabilities.currentExtent.width != width || surfCapabilities.currentExtent.height != height) {
+            resize();
+        }
+    } else if (present_result == vk::Result::eErrorSurfaceLostKHR) {
+        inst.destroySurfaceKHR(surface);
+        create_surface();
+        resize();
+    } else {
+        VERIFY(present_result == vk::Result::eSuccess);
+    }
+}
+
+void Demo::draw_build_cmd(const SubmissionResources &submission_resource, const SwapchainImageResources &swapchain_image_resource) {
+    const auto commandBuffer = submission_resource.cmd;
+    vk::ClearValue const clearValues[2] = {vk::ClearColorValue(std::array<float, 4>({{0.2f, 0.2f, 0.2f, 0.2f}})),
+                                           vk::ClearDepthStencilValue(1.0f, 0u)};
+    auto result = commandBuffer.reset();
+    VERIFY(result == vk::Result::eSuccess);
+
+    result = commandBuffer.begin(vk::CommandBufferBeginInfo().setFlags(vk::CommandBufferUsageFlagBits::eSimultaneousUse));
+    VERIFY(result == vk::Result::eSuccess);
+
+    commandBuffer.beginRenderPass(vk::RenderPassBeginInfo()
+                                      .setRenderPass(render_pass)
+                                      .setFramebuffer(swapchain_image_resource.framebuffer)
+                                      .setRenderArea(vk::Rect2D(vk::Offset2D{}, vk::Extent2D(width, height)))
+                                      .setClearValueCount(2)
+                                      .setPClearValues(clearValues),
+                                  vk::SubpassContents::eInline);
+
+    commandBuffer.bindPipeline(vk::PipelineBindPoint::eGraphics, pipeline);
+    commandBuffer.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipeline_layout, 0, submission_resource.descriptor_set, {});
+    float viewport_dimension;
+    float viewport_x = 0.0f;
+    float viewport_y = 0.0f;
+    if (width < height) {
+        viewport_dimension = static_cast<float>(width);
+        viewport_y = (height - width) / 2.0f;
+    } else {
+        viewport_dimension = static_cast<float>(height);
+        viewport_x = (width - height) / 2.0f;
+    }
+
+    commandBuffer.setViewport(0, vk::Viewport()
+                                     .setX(viewport_x)
+                                     .setY(viewport_y)
+                                     .setWidth(viewport_dimension)
+                                     .setHeight(viewport_dimension)
+                                     .setMinDepth(0.0f)
+                                     .setMaxDepth(1.0f));
+
+    commandBuffer.setScissor(0, vk::Rect2D(vk::Offset2D{}, vk::Extent2D(width, height)));
+    commandBuffer.draw(12 * 3, 1, 0, 0);
+    // Note that ending the renderpass changes the image's layout from
+    // COLOR_ATTACHMENT_OPTIMAL to PRESENT_SRC_KHR
+    commandBuffer.endRenderPass();
+
+    if (separate_present_queue) {
+        // We have to transfer ownership from the graphics queue family to
+        // the
+        // present queue family to be able to present.  Note that we don't
+        // have
+        // to transfer from present queue family back to graphics queue
+        // family at
+        // the start of the next frame because we don't care about the
+        // image's
+        // contents at that point.
+        commandBuffer.pipelineBarrier(
+            vk::PipelineStageFlagBits::eBottomOfPipe, vk::PipelineStageFlagBits::eBottomOfPipe, vk::DependencyFlagBits(), {}, {},
+            vk::ImageMemoryBarrier()
+                .setSrcAccessMask(vk::AccessFlags())
+                .setDstAccessMask(vk::AccessFlags())
+                .setOldLayout(vk::ImageLayout::ePresentSrcKHR)
+                .setNewLayout(vk::ImageLayout::ePresentSrcKHR)
+                .setSrcQueueFamilyIndex(graphics_queue_family_index)
+                .setDstQueueFamilyIndex(present_queue_family_index)
+                .setImage(swapchain_image_resource.image)
+                .setSubresourceRange(vk::ImageSubresourceRange(vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1)));
+    }
+
+    result = commandBuffer.end();
+    VERIFY(result == vk::Result::eSuccess);
+}
+
+void Demo::prepare_init_cmd() {
+    vk::CommandPoolCreateFlags cmd_pool_create_flags =
+        protected_output ? vk::CommandPoolCreateFlagBits::eProtected : vk::CommandPoolCreateFlags{};
+    cmd_pool_create_flags |= vk::CommandPoolCreateFlagBits::eResetCommandBuffer;
+    auto cmd_pool_return = device.createCommandPool(
+        vk::CommandPoolCreateInfo().setQueueFamilyIndex(graphics_queue_family_index).setFlags(cmd_pool_create_flags));
+    VERIFY(cmd_pool_return.result == vk::Result::eSuccess);
+    cmd_pool = cmd_pool_return.value;
+
+    auto cmd_return = device.allocateCommandBuffers(vk::CommandBufferAllocateInfo()
+                                                        .setCommandPool(cmd_pool)
+                                                        .setLevel(vk::CommandBufferLevel::ePrimary)
+                                                        .setCommandBufferCount(1));
+    VERIFY(cmd_return.result == vk::Result::eSuccess);
+    cmd = cmd_return.value[0];
+
+    auto result = cmd.begin(vk::CommandBufferBeginInfo());
+    VERIFY(result == vk::Result::eSuccess);
+}
+
+void Demo::flush_init_cmd() {
+    auto result = cmd.end();
+    VERIFY(result == vk::Result::eSuccess);
+
+    auto fenceInfo = vk::FenceCreateInfo();
+    if (force_errors) {
+        // Remove sType to intentionally force validation layer errors.
+        fenceInfo.sType = vk::StructureType::eRenderPassBeginInfo;
+    }
+    auto fence_return = device.createFence(fenceInfo);
+    VERIFY(fence_return.result == vk::Result::eSuccess);
+    auto fence = fence_return.value;
+
+    auto const protected_submit_info = vk::ProtectedSubmitInfo().setProtectedSubmit(protected_output);
+    result = graphics_queue.submit(
+        vk::SubmitInfo().setPNext(protected_output ? &protected_submit_info : nullptr).setCommandBuffers(cmd), fence);
+    VERIFY(result == vk::Result::eSuccess);
+
+    result = device.waitForFences(fence, VK_TRUE, UINT64_MAX);
+    VERIFY(result == vk::Result::eSuccess);
+
+    device.freeCommandBuffers(cmd_pool, cmd);
+    device.destroyFence(fence);
+}
+
+void Demo::init(int argc, char **argv) {
+    vec3 eye = {0.0f, 3.0f, 5.0f};
+    vec3 origin = {0, 0, 0};
+    vec3 up = {0.0f, 1.0f, 0.0};
+
+    presentMode = vk::PresentModeKHR::eFifo;
+    frameCount = UINT32_MAX;
+    width = 500;
+    height = 500;
+    /* Autodetect suitable / best GPU by default */
+    gpu_number = -1;
+
+    for (int i = 1; i < argc; i++) {
+        if (strcmp(argv[i], "--use_staging") == 0) {
+            use_staging_buffer = true;
+            continue;
+        }
+        if ((strcmp(argv[i], "--present_mode") == 0) && (i < argc - 1)) {
+            presentMode = static_cast<vk::PresentModeKHR>(atoi(argv[i + 1]));
+            i++;
+            continue;
+        }
+        if (strcmp(argv[i], "--break") == 0) {
+            use_break = true;
+            continue;
+        }
+        if (strcmp(argv[i], "--validate") == 0) {
+            validate = true;
+            continue;
+        }
+        if (strcmp(argv[i], "--xlib") == 0) {
+            fprintf(stderr, "--xlib is deprecated and no longer does anything\n");
+            continue;
+        }
+        if (strcmp(argv[i], "--c") == 0 && frameCount == UINT32_MAX && i < argc - 1 &&
+            sscanf(argv[i + 1], "%" SCNu32, &frameCount) == 1) {
+            i++;
+            continue;
+        }
+        if (strcmp(argv[i], "--width") == 0) {
+            int32_t in_width = 0;
+            if (i < argc - 1 && sscanf(argv[i + 1], "%d", &in_width) == 1) {
+                if (in_width > 0) {
+                    width = static_cast<uint32_t>(in_width);
+                    i++;
+                    continue;
+                } else {
+                    ERR_EXIT("The --width parameter must be greater than 0", "User Error");
+                }
+            }
+            ERR_EXIT("The --width parameter must be followed by a number", "User Error");
+        }
+        if (strcmp(argv[i], "--height") == 0) {
+            int32_t in_height = 0;
+            if (i < argc - 1 && sscanf(argv[i + 1], "%d", &in_height) == 1) {
+                if (in_height > 0) {
+                    height = static_cast<uint32_t>(in_height);
+                    i++;
+                    continue;
+                } else {
+                    ERR_EXIT("The --height parameter must be greater than 0", "User Error");
+                }
+            }
+            ERR_EXIT("The --height parameter must be followed by a number", "User Error");
+        }
+        if (strcmp(argv[i], "--suppress_popups") == 0) {
+            suppress_popups = true;
+            continue;
+        }
+        if ((strcmp(argv[i], "--gpu_number") == 0) && (i < argc - 1)) {
+            gpu_number = atoi(argv[i + 1]);
+            if (gpu_number < 0) invalid_gpu_selection = true;
+            i++;
+            continue;
+        }
+        if (strcmp(argv[i], "--force_errors") == 0) {
+            force_errors = true;
+            continue;
+        }
+        if (strcmp(argv[i], "--protected_output") == 0) {
+            protected_output = true;
+            continue;
+        }
+        if ((strcmp(argv[i], "--wsi") == 0) && (i < argc - 1)) {
+            std::string selection_input = argv[i + 1];
+            for (char &c : selection_input) {
+                c = static_cast<char>(std::tolower(c));
+            }
+            WsiPlatform selection = wsi_from_string(selection_input);
+            if (selection == WsiPlatform::invalid) {
+                printf(
+                    "The --wsi parameter %s is not a supported WSI platform. The list of available platforms is available from "
+                    "--help\n",
+                    (const char *)&(argv[i + 1][0]));
+                fflush(stdout);
+                exit(1);
+            }
+            wsi_platform = selection;
+            i++;
+            continue;
+        }
+
+        std::string wsi_platforms;
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+        wsi_platforms.append("xcb");
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+        if (!wsi_platforms.empty()) wsi_platforms.append("|");
+        wsi_platforms.append("xlib");
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+        if (!wsi_platforms.empty()) wsi_platforms.append("|");
+        wsi_platforms.append("wayland");
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+        if (!wsi_platforms.empty()) wsi_platforms.append("|");
+        wsi_platforms.append("directfb");
+#endif
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+        if (!wsi_platforms.empty()) wsi_platforms.append("|");
+        wsi_platforms.append("display");
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+        if (!wsi_platforms.empty()) wsi_platforms.append("|");
+        wsi_platforms.append("metal");
+#endif
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+        if (!wsi_platforms.empty()) wsi_platforms.append("|");
+        wsi_platforms.append("win32");
+#endif
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+        if (!wsi_platforms.empty()) wsi_platforms.append("|");
+        wsi_platforms.append("android");
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+        if (!wsi_platforms.empty()) wsi_platforms.append("|");
+        wsi_platforms.append("qnx");
+#endif
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+        if (!wsi_platforms.empty()) wsi_platforms.append("|");
+        wsi_platforms.append("fuchsia_display");
+        if (!wsi_platforms.empty()) wsi_platforms.append("|");
+        wsi_platforms.append("fuchsia_scenic");
+#endif
+        std::stringstream usage;
+        usage << "Usage:\n  " << APP_SHORT_NAME << "\t[--use_staging] [--validate]\n"
+              << "\t[--break] [--c <framecount>] [--suppress_popups]\n"
+              << "\t[--gpu_number <index of physical device>]\n"
+              << "\t[--present_mode <present mode enum>]\n"
+              << "\t[--width <width>] [--height <height>]\n"
+              << "\t[--force_errors]\n"
+              << "\t[--protected_output]\n"
+              << "\t[--wsi <" << wsi_platforms << ">]\n"
+              << "\t<present_mode_enum>\n"
+              << "\t\tVK_PRESENT_MODE_IMMEDIATE_KHR = " << VK_PRESENT_MODE_IMMEDIATE_KHR << "\n"
+              << "\t\tVK_PRESENT_MODE_MAILBOX_KHR = " << VK_PRESENT_MODE_MAILBOX_KHR << "\n"
+              << "\t\tVK_PRESENT_MODE_FIFO_KHR = " << VK_PRESENT_MODE_FIFO_KHR << "\n"
+              << "\t\tVK_PRESENT_MODE_FIFO_RELAXED_KHR = " << VK_PRESENT_MODE_FIFO_RELAXED_KHR << "\n";
+
+#if defined(_WIN32)
+        if (!suppress_popups) MessageBox(nullptr, usage.str().c_str(), "Usage Error", MB_OK);
+#else
+        std::cerr << usage.str();
+        std::cerr.flush();
+#endif
+        exit(1);
+    }
+
+    initialized = false;
+
+    init_vk();
+
+    spin_angle = 4.0f;
+    spin_increment = 0.2f;
+    pause = false;
+
+    mat4x4_perspective(projection_matrix, static_cast<float>(degreesToRadians(45.0f)), 1.0f, 0.1f, 100.0f);
+    mat4x4_look_at(view_matrix, eye, origin, up);
+    mat4x4_identity(model_matrix);
+
+    projection_matrix[1][1] *= -1;  // Flip projection matrix from GL to Vulkan orientation.
+}
+
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+const char *Demo::init_xcb_connection() {
+    xcb_library = initialize_xcb();
+    if (NULL == xcb_library) {
+        return "Cannot load XLIB dynamic library.";
+    }
+    const xcb_setup_t *setup;
+    xcb_screen_iterator_t iter;
+    int scr;
+
+    const char *display_envar = getenv("DISPLAY");
+    if (display_envar == nullptr || display_envar[0] == '\0') {
+        return "Environment variable DISPLAY requires a valid value.";
+    }
+
+    connection = xcb_connect(nullptr, &scr);
+    if (xcb_connection_has_error(connection) > 0) {
+        return "Cannot connect to XCB.";
+    }
+
+    setup = xcb_get_setup(connection);
+    iter = xcb_setup_roots_iterator(setup);
+    while (scr-- > 0) xcb_screen_next(&iter);
+
+    screen = iter.data;
+    return NULL;
+}
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+const char *Demo::init_xlib_connection() {
+    xlib_library = initialize_xlib();
+    if (NULL == xlib_library) {
+        return "Cannot load XLIB dynamic library.";
+    }
+    return NULL;
+}
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+const char *Demo::init_wayland_connection() {
+    wayland_library = initialize_wayland();
+    if (NULL == wayland_library) {
+        return "Cannot load wayland dynamic library.";
+    }
+    wayland_display = wl_display_connect(nullptr);
+
+    if (wayland_display == nullptr) {
+        return "Cannot connect to wayland.";
+    }
+
+    registry = wl_display_get_registry(wayland_display);
+    wl_registry_add_listener(registry, &registry_listener, this);
+    wl_display_dispatch(wayland_display);
+    return NULL;
+}
+#endif
+
+void Demo::check_and_set_wsi_platform() {
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+    if (wsi_platform == WsiPlatform::wayland || wsi_platform == WsiPlatform::auto_) {
+        auto found = std::find_if(enabled_instance_extensions.begin(), enabled_instance_extensions.end(),
+                                  [](const char *str) { return 0 == strcmp(str, VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME); });
+        if (found != enabled_instance_extensions.end()) {
+            const char *error_msg = init_wayland_connection();
+            if (error_msg != NULL) {
+                if (wsi_platform == WsiPlatform::wayland) {
+                    fprintf(stderr, "%s\nExiting ...\n", error_msg);
+                    fflush(stdout);
+                    exit(1);
+                }
+            } else {
+                wsi_platform = WsiPlatform::wayland;
+                return;
+            }
+        }
+    }
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+    if (wsi_platform == WsiPlatform::xcb || wsi_platform == WsiPlatform::auto_) {
+        auto found = std::find_if(enabled_instance_extensions.begin(), enabled_instance_extensions.end(),
+                                  [](const char *str) { return 0 == strcmp(str, VK_KHR_XCB_SURFACE_EXTENSION_NAME); });
+        if (found != enabled_instance_extensions.end()) {
+            const char *error_msg = init_xcb_connection();
+            if (error_msg != NULL) {
+                if (wsi_platform == WsiPlatform::xcb) {
+                    fprintf(stderr, "%s\nExiting ...\n", error_msg);
+                    fflush(stdout);
+                    exit(1);
+                }
+            } else {
+                wsi_platform = WsiPlatform::xcb;
+                return;
+            }
+        }
+    }
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+    if (wsi_platform == WsiPlatform::xlib || wsi_platform == WsiPlatform::auto_) {
+        auto found = std::find_if(enabled_instance_extensions.begin(), enabled_instance_extensions.end(),
+                                  [](const char *str) { return 0 == strcmp(str, VK_KHR_XLIB_SURFACE_EXTENSION_NAME); });
+        if (found != enabled_instance_extensions.end()) {
+            const char *error_msg = init_xlib_connection();
+            if (error_msg != NULL) {
+                if (wsi_platform == WsiPlatform::xlib) {
+                    fprintf(stderr, "%s\nExiting ...\n", error_msg);
+                    fflush(stdout);
+                    exit(1);
+                }
+            } else {
+                wsi_platform = WsiPlatform::xlib;
+                return;
+            }
+        }
+    }
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+    if (wsi_platform == WsiPlatform::directfb || wsi_platform == WsiPlatform::auto_) {
+        auto found = std::find_if(enabled_instance_extensions.begin(), enabled_instance_extensions.end(),
+                                  [](const char *str) { return 0 == strcmp(str, VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME); });
+        if (found != enabled_instance_extensions.end()) {
+            // Because DirectFB is still linked in, we can assume that it works if we got here
+            wsi_platform = WsiPlatform::directfb;
+            return;
+        }
+    }
+#endif
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+    if (wsi_platform == WsiPlatform::win32 || wsi_platform == WsiPlatform::auto_) {
+        auto found = std::find_if(enabled_instance_extensions.begin(), enabled_instance_extensions.end(),
+                                  [](const char *str) { return 0 == strcmp(str, VK_KHR_WIN32_SURFACE_EXTENSION_NAME); });
+        if (found != enabled_instance_extensions.end()) {
+            wsi_platform = WsiPlatform::win32;
+            return;
+        }
+    }
+#endif
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+    if (wsi_platform == WsiPlatform::android || wsi_platform == WsiPlatform::auto_) {
+        auto found = std::find_if(enabled_instance_extensions.begin(), enabled_instance_extensions.end(),
+                                  [](const char *str) { return 0 == strcmp(str, VK_KHR_ANDROID_SURFACE_EXTENSION_NAME); });
+        if (found != enabled_instance_extensions.end()) {
+            wsi_platform = WsiPlatform::android;
+            return;
+        }
+    }
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+    if (wsi_platform == WsiPlatform::metal || wsi_platform == WsiPlatform::auto_) {
+        auto found = std::find_if(enabled_instance_extensions.begin(), enabled_instance_extensions.end(),
+                                  [](const char *str) { return 0 == strcmp(str, VK_EXT_METAL_SURFACE_EXTENSION_NAME); });
+        if (found != enabled_instance_extensions.end()) {
+            wsi_platform = WsiPlatform::metal;
+            return;
+        }
+    }
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+    if (wsi_platform == WsiPlatform::qnx || wsi_platform == WsiPlatform::auto_) {
+        auto found = std::find_if(enabled_instance_extensions.begin(), enabled_instance_extensions.end(),
+                                  [](const char *str) { return 0 == strcmp(str, VK_QNX_SCREEN_SURFACE_EXTENSION_NAME); });
+        if (found != enabled_instance_extensions.end()) {
+            wsi_platform = WsiPlatform::qnx;
+            return;
+        }
+    }
+#endif
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+    if (wsi_platform == WsiPlatform::display || wsi_platform == WsiPlatform::auto_) {
+        auto found = std::find_if(enabled_instance_extensions.begin(), enabled_instance_extensions.end(),
+                                  [](const char *str) { return 0 == strcmp(str, VK_KHR_DISPLAY_EXTENSION_NAME); });
+        if (found != enabled_instance_extensions.end()) {
+            wsi_platform = WsiPlatform::display;
+            return;
+        }
+    }
+#endif
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+    if (wsi_platform == WsiPlatform::auto_) {
+        ERR_EXIT("auto WSI platform is not supported on Fuchsia", "check_and_set_wsi_platform error");
+    }
+#endif
+}
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+int find_display_gpu(int gpu_number, const std::vector<vk::PhysicalDevice> &physical_devices) {
+    uint32_t display_count = 0;
+    int gpu_return = gpu_number;
+    if (gpu_number >= 0) {
+        auto display_props_return = physical_devices[gpu_number].getDisplayPropertiesKHR();
+        VERIFY(display_props_return.result == vk::Result::eSuccess);
+        display_count = static_cast<uint32_t>(display_props_return.value.size());
+    } else {
+        for (uint32_t i = 0; i < physical_devices.size(); i++) {
+            auto display_props_return = physical_devices[i].getDisplayPropertiesKHR();
+            VERIFY(display_props_return.result == vk::Result::eSuccess);
+            if (display_props_return.value.size() > 0) {
+                display_count = static_cast<uint32_t>(display_props_return.value.size());
+                gpu_return = i;
+                break;
+            }
+        }
+    }
+    if (display_count > 0)
+        return gpu_return;
+    else
+        return -1;
+}
+#endif
+VKAPI_ATTR vk::Bool32 VKAPI_CALL Demo::debug_messenger_callback(vk::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+                                                                vk::DebugUtilsMessageTypeFlagsEXT messageType,
+                                                                const vk::DebugUtilsMessengerCallbackDataEXT *pCallbackData,
+                                                                void *pUserData) {
+    std::ostringstream message;
+    Demo &demo = *static_cast<Demo *>(pUserData);
+
+    if (demo.use_break) {
+#ifndef WIN32
+        raise(SIGTRAP);
+#else
+        DebugBreak();
+#endif
+    }
+    message << vk::to_string(vk::DebugUtilsMessageSeverityFlagBitsEXT(messageSeverity));
+    message << " : " + vk::to_string(vk::DebugUtilsMessageTypeFlagsEXT(messageType));
+
+    if (vk::DebugUtilsMessageTypeFlagsEXT(messageType) & vk::DebugUtilsMessageTypeFlagBitsEXT::eValidation) {
+        validation_error = 1;
+    }
+
+    message << " - Message Id Number: " << std::to_string(pCallbackData->messageIdNumber);
+    message << " | Message Id Name: " << (pCallbackData->pMessageIdName == nullptr ? "" : pCallbackData->pMessageIdName) << "\n\t"
+            << pCallbackData->pMessage << "\n";
+
+    if (pCallbackData->objectCount > 0) {
+        message << "\n\tObjects - " << pCallbackData->objectCount << "\n";
+        for (uint32_t object = 0; object < pCallbackData->objectCount; ++object) {
+            message << "\t\tObject[" << object << "] - "
+                    << vk::to_string(vk::ObjectType(pCallbackData->pObjects[object].objectType)) << ", Handle ";
+
+            // Print handle correctly if it is a dispatchable handle - aka a pointer
+            vk::ObjectType t = pCallbackData->pObjects[object].objectType;
+            if (t == vk::ObjectType::eInstance || t == vk::ObjectType::ePhysicalDevice || t == vk::ObjectType::eDevice ||
+                t == vk::ObjectType::eCommandBuffer || t == vk::ObjectType::eQueue) {
+                message << reinterpret_cast<void *>(static_cast<uintptr_t>(pCallbackData->pObjects[object].objectHandle));
+            } else {
+                message << pCallbackData->pObjects[object].objectHandle;
+            }
+            if (NULL != pCallbackData->pObjects[object].pObjectName && strlen(pCallbackData->pObjects[object].pObjectName) > 0) {
+                message << ", Name \"" << pCallbackData->pObjects[object].pObjectName << "\"\n";
+            } else {
+                message << "\n";
+            }
+        }
+    }
+    if (pCallbackData->cmdBufLabelCount > 0) {
+        message << "\n\tCommand Buffer Labels - " << pCallbackData->cmdBufLabelCount << "\n";
+        for (uint32_t cmd_buf_label = 0; cmd_buf_label < pCallbackData->cmdBufLabelCount; ++cmd_buf_label) {
+            message << "\t\tLabel[" << cmd_buf_label << "] - " << pCallbackData->pCmdBufLabels[cmd_buf_label].pLabelName << " { "
+                    << pCallbackData->pCmdBufLabels[cmd_buf_label].color[0] << ", "
+                    << pCallbackData->pCmdBufLabels[cmd_buf_label].color[1] << ", "
+                    << pCallbackData->pCmdBufLabels[cmd_buf_label].color[2] << ", "
+                    << pCallbackData->pCmdBufLabels[cmd_buf_label].color[2] << "}\n";
+        }
+    }
+
+#ifdef _WIN32
+
+    if (!demo.suppress_popups) {
+        demo.in_callback = true;
+        auto message_string = message.str();
+        MessageBox(NULL, message_string.c_str(), "Alert", MB_OK);
+        demo.in_callback = false;
+    }
+
+#elif defined(ANDROID)
+
+    if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT) {
+        __android_log_print(ANDROID_LOG_INFO, APP_SHORT_NAME, "%s", message.str());
+    } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) {
+        __android_log_print(ANDROID_LOG_WARN, APP_SHORT_NAME, "%s", message.str());
+    } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
+        __android_log_print(ANDROID_LOG_ERROR, APP_SHORT_NAME, "%s", message.str());
+    } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) {
+        __android_log_print(ANDROID_LOG_VERBOSE, APP_SHORT_NAME, "%s", message.str());
+    } else {
+        __android_log_print(ANDROID_LOG_INFO, APP_SHORT_NAME, "%s", message.str());
+    }
+
+#else
+    std::cout << message.str() << std::endl;  // use endl to force a flush
+#endif
+    return false;  // Don't bail out, but keep going.
+}
+
+void Demo::init_vk() {
+    VULKAN_HPP_DEFAULT_DISPATCHER.init();
+
+    uint32_t apiVersion = 0;
+    vk::Result enumerate_instance_version_result = vk::enumerateInstanceVersion(&apiVersion);
+    if (protected_output) {
+        if (enumerate_instance_version_result != vk::Result::eSuccess) {
+            ERR_EXIT("Failed to query instance version.", "vkCreateInstance Failure");
+        }
+        if (apiVersion < VK_MAKE_VERSION(1, 1, 0)) {
+            ERR_EXIT("Need Vulkan 1.1 instance for protected output.", "vkCreateInstance Failure");
+        }
+    }
+
+    std::vector<char const *> instance_validation_layers = {"VK_LAYER_KHRONOS_validation"};
+
+    // Look for validation layers
+    vk::Bool32 validation_found = VK_FALSE;
+    if (validate) {
+        auto layers = vk::enumerateInstanceLayerProperties();
+        VERIFY(layers.result == vk::Result::eSuccess);
+
+        validation_found = check_layers(instance_validation_layers, layers.value);
+        if (validation_found) {
+            enabled_layers.push_back("VK_LAYER_KHRONOS_validation");
+        }
+
+        else {
+            ERR_EXIT(
+                "vkEnumerateInstanceLayerProperties failed to find required validation layer.\n\n"
+                "Please look at the Getting Started guide for additional information.\n",
+                "vkCreateInstance Failure");
+        }
+    }
+
+    /* Look for instance extensions */
+    vk::Bool32 surfaceExtFound = VK_FALSE;
+    vk::Bool32 platformSurfaceExtFound = VK_FALSE;
+    bool portabilityEnumerationActive = false;
+
+    // Some platforms (for example, Fuchsia) may have their WSI instance
+    // extension in layers and require the client to manually specify the
+    // instance extension layer.
+    vk::Optional<const std::string> instance_extension_layer = nullptr;
+#if VK_USE_PLATFORM_FUCHSIA
+    const char *image_pipe_layer_name = get_fuchsia_image_pipe_layer();
+    enabled_layers.push_back(image_pipe_layer_name);
+
+    const std::string image_pipe_layer_name_str = image_pipe_layer_name;
+    instance_extension_layer = image_pipe_layer_name_str;
+#endif  // VK_USE_PLATFORM_FUCHSIA
+
+    auto instance_extensions_return = vk::enumerateInstanceExtensionProperties(instance_extension_layer);
+    VERIFY(instance_extensions_return.result == vk::Result::eSuccess);
+
+    for (const auto &extension : instance_extensions_return.value) {
+        if (!strcmp(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, extension.extensionName)) {
+            enabled_instance_extensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+        } else if (!strcmp(VK_EXT_DEBUG_UTILS_EXTENSION_NAME, extension.extensionName)) {
+            use_debug_messenger = true;
+            enabled_instance_extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
+        } else if (!strcmp(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME, extension.extensionName)) {
+            // We want cube to be able to enumerate drivers that support the portability_subset extension, so we have to enable the
+            // portability enumeration extension.
+            portabilityEnumerationActive = true;
+            enabled_instance_extensions.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
+        } else if (!strcmp(VK_KHR_SURFACE_EXTENSION_NAME, extension.extensionName)) {
+            surfaceExtFound = 1;
+            enabled_instance_extensions.push_back(VK_KHR_SURFACE_EXTENSION_NAME);
+        }
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+        else if (!strcmp(VK_KHR_WIN32_SURFACE_EXTENSION_NAME, extension.extensionName) &&
+                 (wsi_platform == WsiPlatform::auto_ || wsi_platform == WsiPlatform::win32)) {
+            platformSurfaceExtFound = 1;
+            enabled_instance_extensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
+        }
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+        else if (!strcmp(VK_KHR_XLIB_SURFACE_EXTENSION_NAME, extension.extensionName) &&
+                 (wsi_platform == WsiPlatform::auto_ || wsi_platform == WsiPlatform::xlib)) {
+            platformSurfaceExtFound = 1;
+            enabled_instance_extensions.push_back(VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
+        }
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+        else if (!strcmp(VK_KHR_XCB_SURFACE_EXTENSION_NAME, extension.extensionName) &&
+                 (wsi_platform == WsiPlatform::auto_ || wsi_platform == WsiPlatform::xcb)) {
+            platformSurfaceExtFound = 1;
+            enabled_instance_extensions.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME);
+        }
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+        else if (!strcmp(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME, extension.extensionName) &&
+                 (wsi_platform == WsiPlatform::auto_ || wsi_platform == WsiPlatform::wayland)) {
+            platformSurfaceExtFound = 1;
+            enabled_instance_extensions.push_back(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME);
+        }
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+        else if (!strcmp(VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME, extension.extensionName) &&
+                 (wsi_platform == WsiPlatform::auto_ || wsi_platform == WsiPlatform::directfb)) {
+            platformSurfaceExtFound = 1;
+            enabled_instance_extensions.push_back(VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME);
+        }
+#endif
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+        else if (!strcmp(VK_KHR_DISPLAY_EXTENSION_NAME, extension.extensionName) &&
+                 (wsi_platform == WsiPlatform::auto_ || wsi_platform == WsiPlatform::display)) {
+            platformSurfaceExtFound = 1;
+            enabled_instance_extensions.push_back(VK_KHR_DISPLAY_EXTENSION_NAME);
+        }
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+        else if (!strcmp(VK_EXT_METAL_SURFACE_EXTENSION_NAME, extension.extensionName) &&
+                 (wsi_platform == WsiPlatform::auto_ || wsi_platform == WsiPlatform::metal)) {
+            platformSurfaceExtFound = 1;
+            enabled_instance_extensions.push_back(VK_EXT_METAL_SURFACE_EXTENSION_NAME);
+        }
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+        else if (!strcmp(VK_QNX_SCREEN_SURFACE_EXTENSION_NAME, extension.extensionName) &&
+                 (wsi_platform == WsiPlatform::auto_ || wsi_platform == WsiPlatform::qnx)) {
+            platformSurfaceExtFound = 1;
+            enabled_instance_extensions.push_back(VK_QNX_SCREEN_SURFACE_EXTENSION_NAME);
+        }
+#endif
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+        else if (!strcmp(VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME, extension.extensionName)) {
+            platformSurfaceExtFound = 1;
+            enabled_instance_extensions.push_back(VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME);
+        }
+#endif
+    }
+
+    if (!surfaceExtFound) {
+        ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_SURFACE_EXTENSION_NAME
+                 " instance extension.\n\n"
+                 "This indicates that no compatible Vulkan installable client driver (ICD) is present or that the system is not "
+                 "configured to present to the screen. \n",
+                 "vkCreateInstance Failure");
+    }
+
+    if (!platformSurfaceExtFound) {
+        switch (wsi_platform) {
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+            case (WsiPlatform::win32):
+                ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_WIN32_SURFACE_EXTENSION_NAME
+                         " instance extension.\n\n"
+                         "The selected WSI platform win32 is not available, please choose a different WSI platform\n",
+                         "vkCreateInstance Failure");
+                break;
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+            case (WsiPlatform::xcb):
+                ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_XCB_SURFACE_EXTENSION_NAME
+                         " instance extension.\n\n"
+                         "The selected WSI platform xcb is not available, please choose a different WSI platform\n",
+                         "vkCreateInstance Failure");
+                break;
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+            case (WsiPlatform::wayland):
+                ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME
+                         " instance extension.\n\n"
+                         "The selected WSI platform wayland is not available, please choose a different WSI platform\n",
+                         "vkCreateInstance Failure");
+                break;
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+            case (WsiPlatform::xlib):
+                ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_XLIB_SURFACE_EXTENSION_NAME
+                         " instance extension.\n\n"
+                         "The selected WSI platform xlib is not available, please choose a different WSI platform\n",
+                         "vkCreateInstance Failure");
+                break;
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+            case (WsiPlatform::directfb):
+                ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME
+                         " instance extension.\n\n"
+                         "The selected WSI platform directfb is not available, please choose a different WSI platform\n",
+                         "vkCreateInstance Failure");
+                break;
+#endif
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+            case (WsiPlatform::display):
+                ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_DISPLAY_EXTENSION_NAME
+                         " instance extension.\n\n"
+                         "The selected WSI platform display is not available, please choose a different WSI platform\n",
+                         "vkCreateInstance Failure");
+                break;
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+            case (WsiPlatform::metal):
+                ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_EXT_METAL_SURFACE_EXTENSION_NAME
+                         " instance extension.\n\n"
+                         "The selected WSI platform metal is not available, please choose a different WSI platform\n",
+                         "vkCreateInstance Failure");
+                break;
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+            case (WsiPlatform::qnx):
+                ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_QNX_SCREEN_SURFACE_EXTENSION_NAME
+                         " instance extension.\n\n"
+                         "The selected WSI platform qnx is not available, please choose a different WSI platform\n",
+                         "vkCreateInstance Failure");
+                break;
+#endif
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+            case (WsiPlatform::fuchsia_display):
+            case (WsiPlatform::fuchsia_scenic):
+                ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME
+                         " instance extension.\n\n"
+                         "The selected WSI platform fuschia is not available, please choose a different WSI platform\n",
+                         "vkCreateInstance Failure");
+                break;
+#endif
+            default:
+            case (WsiPlatform::auto_):
+                // Getting here indicates we are using the WSI extension that is default on this platform
+                ERR_EXIT(
+                    "vkEnumerateInstanceExtensionProperties failed to find any supported WSI surface instance extensions.\n\n"
+                    "This indicates that no compatible Vulkan installable client driver (ICD) is present or that the system is not "
+                    "configured to present to the screen. \n",
+                    "vkCreateInstance Failure");
+        }
+    }
+
+    bool auto_wsi_platform = wsi_platform == WsiPlatform::auto_;
+
+    check_and_set_wsi_platform();
+
+    // Print a message to indicate the automatically set WSI platform
+    if (auto_wsi_platform && wsi_platform != WsiPlatform::auto_) {
+        fprintf(stderr, "Selected WSI platform: %s\n", wsi_to_string(wsi_platform));
+    }
+
+    vk::DebugUtilsMessageSeverityFlagsEXT severityFlags(vk::DebugUtilsMessageSeverityFlagBitsEXT::eWarning |
+                                                        vk::DebugUtilsMessageSeverityFlagBitsEXT::eError);
+    vk::DebugUtilsMessageTypeFlagsEXT messageTypeFlags(vk::DebugUtilsMessageTypeFlagBitsEXT::eGeneral |
+                                                       vk::DebugUtilsMessageTypeFlagBitsEXT::ePerformance |
+                                                       vk::DebugUtilsMessageTypeFlagBitsEXT::eValidation);
+    auto debug_utils_create_info = vk::DebugUtilsMessengerCreateInfoEXT({}, severityFlags, messageTypeFlags,
+                                                                        &debug_messenger_callback, static_cast<void *>(this));
+
+    auto const app = vk::ApplicationInfo()
+                         .setPApplicationName(APP_SHORT_NAME)
+                         .setApplicationVersion(0)
+                         .setPEngineName(APP_SHORT_NAME)
+                         .setEngineVersion(0)
+                         .setApiVersion(VK_API_VERSION_1_0);
+    auto const inst_info = vk::InstanceCreateInfo()
+                               .setFlags(portabilityEnumerationActive ? vk::InstanceCreateFlagBits::eEnumeratePortabilityKHR
+                                                                      : static_cast<vk::InstanceCreateFlagBits>(0))
+                               .setPNext((use_debug_messenger && validate) ? &debug_utils_create_info : nullptr)
+                               .setPApplicationInfo(&app)
+                               .setPEnabledLayerNames(enabled_layers)
+                               .setPEnabledExtensionNames(enabled_instance_extensions);
+
+    auto instance_result = vk::createInstance(inst_info);
+    if (instance_result.result == vk::Result::eErrorIncompatibleDriver) {
+        ERR_EXIT(
+            "Cannot find a compatible Vulkan installable client driver (ICD).\n\n"
+            "Please look at the Getting Started guide for additional information.\n",
+            "vkCreateInstance Failure");
+    } else if (instance_result.result == vk::Result::eErrorExtensionNotPresent) {
+        ERR_EXIT(
+            "Cannot find a specified extension library.\n"
+            "Make sure your layers path is set appropriately.\n",
+            "vkCreateInstance Failure");
+    } else if (instance_result.result != vk::Result::eSuccess) {
+        ERR_EXIT(
+            "vkCreateInstance failed.\n\n"
+            "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
+            "Please look at the Getting Started guide for additional information.\n",
+            "vkCreateInstance Failure");
+    }
+    inst = instance_result.value;
+    VULKAN_HPP_DEFAULT_DISPATCHER.init(inst);
+
+    if (use_debug_messenger) {
+        auto create_debug_messenger_return = inst.createDebugUtilsMessengerEXT(debug_utils_create_info);
+        VERIFY(create_debug_messenger_return.result == vk::Result::eSuccess);
+        debug_messenger = create_debug_messenger_return.value;
+    }
+}
+
+void Demo::select_physical_device() {
+    auto physical_device_return = inst.enumeratePhysicalDevices();
+    VERIFY(physical_device_return.result == vk::Result::eSuccess);
+    auto physical_devices = physical_device_return.value;
+
+    if (physical_devices.size() <= 0) {
+        ERR_EXIT(
+            "vkEnumeratePhysicalDevices reported zero accessible devices.\n\n"
+            "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
+            "Please look at the Getting Started guide for additional information.\n",
+            "vkEnumeratePhysicalDevices Failure");
+    }
+
+    if (invalid_gpu_selection || (gpu_number >= 0 && !(static_cast<uint32_t>(gpu_number) < physical_devices.size()))) {
+        fprintf(stderr, "GPU %d specified is not present, GPU count = %zu\n", gpu_number, physical_devices.size());
+        ERR_EXIT("Specified GPU number is not present", "User Error");
+    }
+
+    if (wsi_platform == WsiPlatform::display) {
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+        gpu_number = find_display_gpu(gpu_number, physical_devices);
+        if (gpu_number < 0) {
+            printf("Cannot find any display!\n");
+            fflush(stdout);
+            exit(1);
+        }
+#else
+        printf(
+            "WSI selection was set to DISPLAY but vkcubepp was not compiled with support for the DISPLAY platform, exiting "
+            "\n");
+        fflush(stdout);
+        exit(1);
+#endif
+    } else {
+        /* Try to auto select most suitable device */
+        if (gpu_number == -1) {
+            int prev_priority = 0;
+            for (uint32_t i = 0; i < physical_devices.size(); i++) {
+                const auto physicalDeviceProperties = physical_devices[i].getProperties();
+                assert(physicalDeviceProperties.deviceType <= vk::PhysicalDeviceType::eCpu);
+
+                auto support_result = physical_devices[i].getSurfaceSupportKHR(0, surface);
+                if (support_result.result != vk::Result::eSuccess || support_result.value != vk::True) {
+                    continue;
+                }
+
+                std::map<vk::PhysicalDeviceType, int> device_type_priorities = {
+                    {vk::PhysicalDeviceType::eDiscreteGpu, 5}, {vk::PhysicalDeviceType::eIntegratedGpu, 4},
+                    {vk::PhysicalDeviceType::eVirtualGpu, 3},  {vk::PhysicalDeviceType::eCpu, 2},
+                    {vk::PhysicalDeviceType::eOther, 1},
+                };
+                int priority = -1;
+                if (device_type_priorities.find(physicalDeviceProperties.deviceType) != device_type_priorities.end()) {
+                    priority = device_type_priorities[physicalDeviceProperties.deviceType];
+                }
+
+                if (priority > prev_priority) {
+                    gpu_number = i;
+                    prev_priority = priority;
+                }
+            }
+        }
+    }
+    assert(gpu_number >= 0);
+    gpu = physical_devices[gpu_number];
+    {
+        auto physicalDeviceProperties = gpu.getProperties();
+        fprintf(stderr, "Selected GPU %d: %s, type: %s\n", gpu_number, physicalDeviceProperties.deviceName.data(),
+                to_string(physicalDeviceProperties.deviceType).c_str());
+    }
+
+    /* Look for device extensions */
+    vk::Bool32 swapchainExtFound = VK_FALSE;
+
+    // Some platforms (for example, Fuchsia) may have their device swapchain
+    // extension in layers and require the client to manually specify the
+    // device swapchain extension layer.
+    vk::Optional<const std::string> device_extension_layer = nullptr;
+#if VK_USE_PLATFORM_FUCHSIA
+    const std::string image_pipe_layer_name = get_fuchsia_image_pipe_layer();
+    device_extension_layer = image_pipe_layer_name;
+#endif  // VK_USE_PLATFORM_FUCHSIA
+
+    // Currently we assume that the device swapchain extension layer is always
+    // enabled when the instance is initialized.
+    assert((!device_extension_layer) || (std::any_of(enabled_layers.begin(), enabled_layers.end(), [&](const char *layer_name) {
+               return *device_extension_layer == layer_name;
+           })));
+
+    auto device_extension_return = gpu.enumerateDeviceExtensionProperties(device_extension_layer);
+    VERIFY(device_extension_return.result == vk::Result::eSuccess);
+
+    for (const auto &extension : device_extension_return.value) {
+        if (!strcmp(VK_KHR_SWAPCHAIN_EXTENSION_NAME, extension.extensionName)) {
+            swapchainExtFound = 1;
+            enabled_device_extensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+        } else if (!strcmp("VK_KHR_portability_subset", extension.extensionName)) {
+            enabled_device_extensions.push_back("VK_KHR_portability_subset");
+        }
+    }
+
+    if (!swapchainExtFound) {
+        ERR_EXIT("vkEnumerateDeviceExtensionProperties failed to find the " VK_KHR_SWAPCHAIN_EXTENSION_NAME
+                 " extension.\n\n"
+                 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
+                 "Please look at the Getting Started guide for additional information.\n",
+                 "vkCreateInstance Failure");
+    }
+
+    gpu.getProperties(&gpu_props);
+
+    if (protected_output && gpu_props.apiVersion < VK_MAKE_VERSION(1, 1, 0)) {
+        ERR_EXIT("Need Vulkan 1.1 physical device for protected output.", "VkPhysicalDevice failure");
+    }
+
+    /* Call with nullptr data to get count */
+    queue_props = gpu.getQueueFamilyProperties();
+    assert(queue_props.size() >= 1);
+
+    // Query fine-grained feature support for this device.
+    //  If app has specific feature requirements it should check supported
+    //  features based on this query
+    vk::PhysicalDeviceFeatures physDevFeatures;
+    gpu.getFeatures(&physDevFeatures);
+}
+
+void Demo::create_surface() {
+// Create a WSI surface for the window:
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+    if (wsi_platform == WsiPlatform::win32) {
+        auto const createInfo = vk::Win32SurfaceCreateInfoKHR().setHinstance(connection).setHwnd(window);
+
+        auto result = inst.createWin32SurfaceKHR(&createInfo, nullptr, &surface);
+        VERIFY(result == vk::Result::eSuccess);
+    }
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+
+    if (wsi_platform == WsiPlatform::wayland) {
+        auto const createInfo = vk::WaylandSurfaceCreateInfoKHR().setDisplay(wayland_display).setSurface(wayland_window);
+
+        auto result = inst.createWaylandSurfaceKHR(&createInfo, nullptr, &surface);
+        VERIFY(result == vk::Result::eSuccess);
+        return;
+    }
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+    if (wsi_platform == WsiPlatform::xlib) {
+        auto const createInfo = vk::XlibSurfaceCreateInfoKHR().setDpy(xlib_display).setWindow(xlib_window);
+
+        auto result = inst.createXlibSurfaceKHR(&createInfo, nullptr, &surface);
+        VERIFY(result == vk::Result::eSuccess);
+    }
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+    if (wsi_platform == WsiPlatform::xcb) {
+        auto const createInfo = vk::XcbSurfaceCreateInfoKHR().setConnection(connection).setWindow(xcb_window);
+
+        auto result = inst.createXcbSurfaceKHR(&createInfo, nullptr, &surface);
+        VERIFY(result == vk::Result::eSuccess);
+    }
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+    if (wsi_platform == WsiPlatform::directfb) {
+        auto const createInfo = vk::DirectFBSurfaceCreateInfoEXT().setDfb(dfb).setSurface(directfb_window);
+
+        auto result = inst.createDirectFBSurfaceEXT(&createInfo, nullptr, &surface);
+        VERIFY(result == vk::Result::eSuccess);
+    }
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+    {
+        auto const createInfo = vk::MetalSurfaceCreateInfoEXT().setPLayer(static_cast<CAMetalLayer *>(caMetalLayer));
+
+        auto result = inst.createMetalSurfaceEXT(&createInfo, nullptr, &surface);
+        VERIFY(result == vk::Result::eSuccess);
+    }
+#endif
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+    if (wsi_platform == WsiPlatform::display) {
+        auto result = create_display_surface();
+        VERIFY(result == vk::Result::eSuccess);
+    }
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+    if (wsi_platform == WsiPlatform::qnx) {
+        auto const createInfo = vk::ScreenSurfaceCreateInfoQNX().setContext(screen_context).setWindow(screen_window);
+
+        auto result = inst.createScreenSurfaceQNX(&createInfo, nullptr, &surface);
+        VERIFY(result == vk::Result::eSuccess);
+    }
+#endif
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+    if (wsi_platform == WsiPlatform::fuchsia_display) {
+        auto createInfo = vk::ImagePipeSurfaceCreateInfoFUCHSIA();
+        auto result = inst.createImagePipeSurfaceFUCHSIA(&createInfo, nullptr, &surface);
+        VERIFY(result == vk::Result::eSuccess);
+    }
+    if (wsi_platform == WsiPlatform::fuchsia_scenic) {
+        auto createInfo = vk::ImagePipeSurfaceCreateInfoFUCHSIA();
+        // We are using ImagePipeSurface here, but it is being migrated to Flatland and the handle parameter is Flatland's
+        // ViewCreationToken during this process.
+        createInfo.setImagePipeHandle(std::move(view_creation_token).value().release());
+        auto result = inst.createImagePipeSurfaceFUCHSIA(&createInfo, nullptr, &surface);
+        VERIFY(result == vk::Result::eSuccess);
+    }
+#endif
+}
+
+void Demo::init_vk_swapchain() {
+    // Iterate over each queue to learn whether it supports presenting:
+    std::vector<vk::Bool32> supportsPresent;
+    for (uint32_t i = 0; i < static_cast<uint32_t>(queue_props.size()); i++) {
+        auto supports = gpu.getSurfaceSupportKHR(i, surface);
+        VERIFY(supports.result == vk::Result::eSuccess);
+        supportsPresent.push_back(supports.value);
+    }
+
+    uint32_t graphicsQueueFamilyIndex = UINT32_MAX;
+    uint32_t presentQueueFamilyIndex = UINT32_MAX;
+    for (uint32_t i = 0; i < static_cast<uint32_t>(queue_props.size()); i++) {
+        if (queue_props[i].queueFlags & vk::QueueFlagBits::eGraphics) {
+            if (graphicsQueueFamilyIndex == UINT32_MAX) {
+                graphicsQueueFamilyIndex = i;
+            }
+
+            if (supportsPresent[i] == VK_TRUE) {
+                graphicsQueueFamilyIndex = i;
+                presentQueueFamilyIndex = i;
+                break;
+            }
+        }
+    }
+
+    if (presentQueueFamilyIndex == UINT32_MAX) {
+        // If didn't find a queue that supports both graphics and present,
+        // then
+        // find a separate present queue.
+        for (uint32_t i = 0; i < queue_props.size(); ++i) {
+            if (supportsPresent[i] == VK_TRUE) {
+                presentQueueFamilyIndex = i;
+                break;
+            }
+        }
+    }
+
+    // Generate error if could not find both a graphics and a present queue
+    if (graphicsQueueFamilyIndex == UINT32_MAX || presentQueueFamilyIndex == UINT32_MAX) {
+        ERR_EXIT("Could not find both graphics and present queues\n", "Swapchain Initialization Failure");
+    }
+
+    graphics_queue_family_index = graphicsQueueFamilyIndex;
+    present_queue_family_index = presentQueueFamilyIndex;
+    separate_present_queue = (graphics_queue_family_index != present_queue_family_index);
+
+    create_device();
+
+    if (protected_output) {
+        auto const queue_info2 = vk::DeviceQueueInfo2()
+                                     .setFlags(vk::DeviceQueueCreateFlagBits::eProtected)
+                                     .setQueueFamilyIndex(graphics_queue_family_index)
+                                     .setQueueIndex(0);
+        device.getQueue2(&queue_info2, &graphics_queue);
+    } else {
+        graphics_queue = device.getQueue(graphics_queue_family_index, 0);
+    }
+
+    if (!separate_present_queue) {
+        present_queue = graphics_queue;
+    } else {
+        present_queue = device.getQueue(present_queue_family_index, 0);
+    }
+
+    // Get the list of VkFormat's that are supported:
+    auto surface_formats_return = gpu.getSurfaceFormatsKHR(surface);
+    VERIFY(surface_formats_return.result == vk::Result::eSuccess);
+
+    vk::SurfaceFormatKHR surfaceFormat = pick_surface_format(surface_formats_return.value);
+    format = surfaceFormat.format;
+    color_space = surfaceFormat.colorSpace;
+
+    quit = false;
+    first_swapchain_frame = true;
+    curFrame = 0;
+
+    // Get Memory information and properties
+    memory_properties = gpu.getMemoryProperties();
+}
+
+void Demo::prepare() {
+    prepare_init_cmd();
+    prepare_textures();
+    prepare_cube_data_buffers();
+
+    prepare_descriptor_layout();
+    // Only need to know the format of the depth buffer before we create the renderpass
+    depth.format = vk::Format::eD16Unorm;
+    prepare_render_pass();
+    prepare_pipeline();
+
+    for (auto &submission_resource : submission_resources) {
+        auto alloc_return = device.allocateCommandBuffers(vk::CommandBufferAllocateInfo()
+                                                              .setCommandPool(cmd_pool)
+                                                              .setLevel(vk::CommandBufferLevel::ePrimary)
+                                                              .setCommandBufferCount(1));
+        VERIFY(alloc_return.result == vk::Result::eSuccess);
+        submission_resource.cmd = alloc_return.value[0];
+    }
+
+    if (separate_present_queue) {
+        auto present_cmd_pool_return =
+            device.createCommandPool(vk::CommandPoolCreateInfo().setQueueFamilyIndex(present_queue_family_index));
+        VERIFY(present_cmd_pool_return.result == vk::Result::eSuccess);
+        present_cmd_pool = present_cmd_pool_return.value;
+
+        for (auto &submission_resource : submission_resources) {
+            auto alloc_cmd_return = device.allocateCommandBuffers(vk::CommandBufferAllocateInfo()
+                                                                      .setCommandPool(present_cmd_pool)
+                                                                      .setLevel(vk::CommandBufferLevel::ePrimary)
+                                                                      .setCommandBufferCount(1));
+            VERIFY(alloc_cmd_return.result == vk::Result::eSuccess);
+            submission_resource.graphics_to_present_cmd = alloc_cmd_return.value[0];
+        }
+    }
+
+    prepare_descriptor_pool();
+    prepare_descriptor_set();
+
+    prepare_framebuffers();
+
+    prepare_submission_sync_objects();
+
+    /*
+     * Prepare functions above may generate pipeline commands
+     * that need to be flushed before beginning the render loop.
+     */
+    flush_init_cmd();
+    if (staging_texture.buffer) {
+        destroy_texture(staging_texture);
+    }
+
+    initialized = true;
+
+    prepare_swapchain();
+}
+
+// Creates the swapchain, swapchain image views, depth buffer, framebuffers, and sempahores.
+// This function returns early if it fails to create a swapchain, setting swapchain_ready to false.
+void Demo::prepare_swapchain() {
+    vk::SwapchainKHR oldSwapchain = swapchain;
+
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+    if (wsi_platform == WsiPlatform::wayland && !xdg_surface_has_been_configured) {
+        return;
+    }
+#endif
+
+    // Check the surface capabilities and formats
+    auto surface_capabilities_return = gpu.getSurfaceCapabilitiesKHR(surface);
+    VERIFY(surface_capabilities_return.result == vk::Result::eSuccess);
+    auto surfCapabilities = surface_capabilities_return.value;
+
+    auto present_modes_return = gpu.getSurfacePresentModesKHR(surface);
+    VERIFY(present_modes_return.result == vk::Result::eSuccess);
+    auto present_modes = present_modes_return.value;
+
+    vk::Extent2D swapchainExtent;
+    // width and height are either both -1, or both not -1.
+    if (surfCapabilities.currentExtent.width == static_cast<uint32_t>(-1)) {
+        // If the surface size is undefined, the size is set to
+        // the size of the images requested.
+        swapchainExtent.width = width;
+        swapchainExtent.height = height;
+    } else {
+        // If the surface size is defined, the swap chain size must match
+        swapchainExtent = surfCapabilities.currentExtent;
+        width = surfCapabilities.currentExtent.width;
+        height = surfCapabilities.currentExtent.height;
+    }
+
+    if (width == 0 || height == 0) {
+        is_minimized = true;
+        return;
+    } else {
+        is_minimized = false;
+    }
+    // The FIFO present mode is guaranteed by the spec to be supported
+    // and to have no tearing.  It's a great default present mode to use.
+    vk::PresentModeKHR swapchainPresentMode = vk::PresentModeKHR::eFifo;
+
+    //  There are times when you may wish to use another present mode.  The
+    //  following code shows how to select them, and the comments provide some
+    //  reasons you may wish to use them.
+    //
+    // It should be noted that Vulkan 1.0 doesn't provide a method for
+    // synchronizing rendering with the presentation engine's display.  There
+    // is a method provided for throttling rendering with the display, but
+    // there are some presentation engines for which this method will not work.
+    // If an application doesn't throttle its rendering, and if it renders much
+    // faster than the refresh rate of the display, this can waste power on
+    // mobile devices.  That is because power is being spent rendering images
+    // that may never be seen.
+
+    // VK_PRESENT_MODE_IMMEDIATE_KHR is for applications that don't care
+    // about
+    // tearing, or have some way of synchronizing their rendering with the
+    // display.
+    // VK_PRESENT_MODE_MAILBOX_KHR may be useful for applications that
+    // generally render a new presentable image every refresh cycle, but are
+    // occasionally early.  In this case, the application wants the new
+    // image
+    // to be displayed instead of the previously-queued-for-presentation
+    // image
+    // that has not yet been displayed.
+    // VK_PRESENT_MODE_FIFO_RELAXED_KHR is for applications that generally
+    // render a new presentable image every refresh cycle, but are
+    // occasionally
+    // late.  In this case (perhaps because of stuttering/latency concerns),
+    // the application wants the late image to be immediately displayed,
+    // even
+    // though that may mean some tearing.
+
+    if (presentMode != swapchainPresentMode) {
+        for (const auto &mode : present_modes) {
+            if (mode == presentMode) {
+                swapchainPresentMode = mode;
+                break;
+            }
+        }
+    }
+
+    if (swapchainPresentMode != presentMode) {
+        ERR_EXIT("Present mode specified is not supported\n", "Present mode unsupported");
+    }
+
+    // Determine the number of VkImages to use in the swap chain.
+    // Application desires to acquire 3 images at a time for triple
+    // buffering
+    uint32_t desiredNumOfSwapchainImages = 3;
+    if (desiredNumOfSwapchainImages < surfCapabilities.minImageCount) {
+        desiredNumOfSwapchainImages = surfCapabilities.minImageCount;
+    }
+
+    // If maxImageCount is 0, we can ask for as many images as we want,
+    // otherwise
+    // we're limited to maxImageCount
+    if ((surfCapabilities.maxImageCount > 0) && (desiredNumOfSwapchainImages > surfCapabilities.maxImageCount)) {
+        // Application must settle for fewer images than desired:
+        desiredNumOfSwapchainImages = surfCapabilities.maxImageCount;
+    }
+
+    vk::SurfaceTransformFlagBitsKHR preTransform;
+    if (surfCapabilities.supportedTransforms & vk::SurfaceTransformFlagBitsKHR::eIdentity) {
+        preTransform = vk::SurfaceTransformFlagBitsKHR::eIdentity;
+    } else {
+        preTransform = surfCapabilities.currentTransform;
+    }
+
+    // Find a supported composite alpha mode - one of these is guaranteed to be set
+    vk::CompositeAlphaFlagBitsKHR compositeAlpha = vk::CompositeAlphaFlagBitsKHR::eOpaque;
+    std::array<vk::CompositeAlphaFlagBitsKHR, 4> compositeAlphaFlags = {
+        vk::CompositeAlphaFlagBitsKHR::eOpaque,
+        vk::CompositeAlphaFlagBitsKHR::ePreMultiplied,
+        vk::CompositeAlphaFlagBitsKHR::ePostMultiplied,
+        vk::CompositeAlphaFlagBitsKHR::eInherit,
+    };
+    for (const auto &compositeAlphaFlag : compositeAlphaFlags) {
+        if (surfCapabilities.supportedCompositeAlpha & compositeAlphaFlag) {
+            compositeAlpha = compositeAlphaFlag;
+            break;
+        }
+    }
+
+    const vk::SwapchainCreateFlagsKHR swapchain_create_flags =
+        protected_output ? vk::SwapchainCreateFlagBitsKHR::eProtected : vk::SwapchainCreateFlagsKHR{};
+    auto swapchain_return = device.createSwapchainKHR(vk::SwapchainCreateInfoKHR()
+                                                          .setSurface(surface)
+                                                          .setMinImageCount(desiredNumOfSwapchainImages)
+                                                          .setImageFormat(format)
+                                                          .setImageColorSpace(color_space)
+                                                          .setImageExtent({swapchainExtent.width, swapchainExtent.height})
+                                                          .setImageArrayLayers(1)
+                                                          .setImageUsage(vk::ImageUsageFlagBits::eColorAttachment)
+                                                          .setImageSharingMode(vk::SharingMode::eExclusive)
+                                                          .setPreTransform(preTransform)
+                                                          .setCompositeAlpha(compositeAlpha)
+                                                          .setPresentMode(swapchainPresentMode)
+                                                          .setClipped(true)
+                                                          .setOldSwapchain(oldSwapchain)
+                                                          .setFlags(swapchain_create_flags));
+    VERIFY(swapchain_return.result == vk::Result::eSuccess);
+    swapchain = swapchain_return.value;
+
+    // If we just re-created an existing swapchain, we should destroy the
+    // old
+    // swapchain at this point.
+    // Note: destroying the swapchain also cleans up all its associated
+    // presentable images once the platform is done with them.
+    if (oldSwapchain) {
+        device.destroySwapchainKHR(oldSwapchain);
+    }
+
+    auto swapchain_images_return = device.getSwapchainImagesKHR(swapchain);
+    VERIFY(swapchain_images_return.result == vk::Result::eSuccess);
+    swapchain_resources.resize(swapchain_images_return.value.size());
+
+    for (uint32_t i = 0; i < swapchain_resources.size(); ++i) {
+        auto color_image_view = vk::ImageViewCreateInfo()
+                                    .setViewType(vk::ImageViewType::e2D)
+                                    .setFormat(format)
+                                    .setSubresourceRange(vk::ImageSubresourceRange(vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1));
+
+        swapchain_resources[i].image = swapchain_images_return.value[i];
+
+        color_image_view.image = swapchain_resources[i].image;
+
+        auto image_view_return = device.createImageView(color_image_view);
+        VERIFY(image_view_return.result == vk::Result::eSuccess);
+        swapchain_resources[i].view = image_view_return.value;
+    }
+
+    // Create semaphores to synchronize acquiring presentable buffers before
+    // rendering and waiting for drawing to be complete before presenting
+    auto const semaphoreCreateInfo = vk::SemaphoreCreateInfo();
+
+    for (auto &swapchain_resource : swapchain_resources) {
+        auto result = device.createSemaphore(&semaphoreCreateInfo, nullptr, &swapchain_resource.draw_complete_semaphore);
+        VERIFY(result == vk::Result::eSuccess);
+
+        if (separate_present_queue) {
+            result = device.createSemaphore(&semaphoreCreateInfo, nullptr, &swapchain_resource.image_ownership_semaphore);
+            VERIFY(result == vk::Result::eSuccess);
+        }
+    }
+
+    prepare_depth();
+    prepare_framebuffers();
+    swapchain_ready = true;
+    first_swapchain_frame = true;
+}
+
+void Demo::prepare_cube_data_buffers() {
+    mat4x4 VP;
+    mat4x4_mul(VP, projection_matrix, view_matrix);
+
+    mat4x4 MVP;
+    mat4x4_mul(MVP, VP, model_matrix);
+
+    vktexcube_vs_uniform data;
+    memcpy(data.mvp, MVP, sizeof(MVP));
+    //    dumpMatrix("MVP", MVP)
+
+    for (int32_t i = 0; i < 12 * 3; i++) {
+        data.position[i][0] = g_vertex_buffer_data[i * 3];
+        data.position[i][1] = g_vertex_buffer_data[i * 3 + 1];
+        data.position[i][2] = g_vertex_buffer_data[i * 3 + 2];
+        data.position[i][3] = 1.0f;
+        data.attr[i][0] = g_uv_buffer_data[2 * i];
+        data.attr[i][1] = g_uv_buffer_data[2 * i + 1];
+        data.attr[i][2] = 0;
+        data.attr[i][3] = 0;
+    }
+
+    auto const buf_info = vk::BufferCreateInfo().setSize(sizeof(data)).setUsage(vk::BufferUsageFlagBits::eUniformBuffer);
+
+    for (auto &submission_resource : submission_resources) {
+        auto result = device.createBuffer(&buf_info, nullptr, &submission_resource.uniform_buffer);
+        VERIFY(result == vk::Result::eSuccess);
+
+        vk::MemoryRequirements mem_reqs;
+        device.getBufferMemoryRequirements(submission_resource.uniform_buffer, &mem_reqs);
+
+        auto mem_alloc = vk::MemoryAllocateInfo().setAllocationSize(mem_reqs.size).setMemoryTypeIndex(0);
+
+        bool const pass = memory_type_from_properties(
+            mem_reqs.memoryTypeBits, vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent,
+            mem_alloc.memoryTypeIndex);
+        VERIFY(pass);
+
+        result = device.allocateMemory(&mem_alloc, nullptr, &submission_resource.uniform_memory);
+        VERIFY(result == vk::Result::eSuccess);
+
+        result = device.mapMemory(submission_resource.uniform_memory, 0, VK_WHOLE_SIZE, vk::MemoryMapFlags(),
+                                  &submission_resource.uniform_memory_ptr);
+        VERIFY(result == vk::Result::eSuccess);
+
+        memcpy(submission_resource.uniform_memory_ptr, &data, sizeof data);
+
+        result = device.bindBufferMemory(submission_resource.uniform_buffer, submission_resource.uniform_memory, 0);
+        VERIFY(result == vk::Result::eSuccess);
+    }
+}
+
+void Demo::prepare_depth() {
+    depth.format = vk::Format::eD16Unorm;
+
+    auto const image = vk::ImageCreateInfo()
+                           .setImageType(vk::ImageType::e2D)
+                           .setFormat(depth.format)
+                           .setExtent({width, height, 1})
+                           .setMipLevels(1)
+                           .setArrayLayers(1)
+                           .setSamples(vk::SampleCountFlagBits::e1)
+                           .setTiling(vk::ImageTiling::eOptimal)
+                           .setUsage(vk::ImageUsageFlagBits::eDepthStencilAttachment)
+                           .setSharingMode(vk::SharingMode::eExclusive)
+                           .setInitialLayout(vk::ImageLayout::eUndefined);
+
+    auto result = device.createImage(&image, nullptr, &depth.image);
+    VERIFY(result == vk::Result::eSuccess);
+
+    vk::MemoryRequirements mem_reqs;
+    device.getImageMemoryRequirements(depth.image, &mem_reqs);
+
+    depth.mem_alloc.setAllocationSize(mem_reqs.size);
+    depth.mem_alloc.setMemoryTypeIndex(0);
+
+    auto const pass = memory_type_from_properties(mem_reqs.memoryTypeBits, vk::MemoryPropertyFlagBits::eDeviceLocal,
+                                                  depth.mem_alloc.memoryTypeIndex);
+    VERIFY(pass);
+
+    result = device.allocateMemory(&depth.mem_alloc, nullptr, &depth.mem);
+    VERIFY(result == vk::Result::eSuccess);
+
+    result = device.bindImageMemory(depth.image, depth.mem, 0);
+    VERIFY(result == vk::Result::eSuccess);
+
+    auto view = vk::ImageViewCreateInfo()
+                    .setImage(depth.image)
+                    .setViewType(vk::ImageViewType::e2D)
+                    .setFormat(depth.format)
+                    .setSubresourceRange(vk::ImageSubresourceRange(vk::ImageAspectFlagBits::eDepth, 0, 1, 0, 1));
+    if (force_errors) {
+        // Intentionally force a bad pNext value to generate a validation layer error
+        view.pNext = &image;
+    }
+    result = device.createImageView(&view, nullptr, &depth.view);
+    VERIFY(result == vk::Result::eSuccess);
+}
+
+void Demo::prepare_descriptor_layout() {
+    std::array<vk::DescriptorSetLayoutBinding, 2> const layout_bindings = {
+        vk::DescriptorSetLayoutBinding()
+            .setBinding(0)
+            .setDescriptorType(vk::DescriptorType::eUniformBuffer)
+            .setDescriptorCount(1)
+            .setStageFlags(vk::ShaderStageFlagBits::eVertex)
+            .setPImmutableSamplers(nullptr),
+        vk::DescriptorSetLayoutBinding()
+            .setBinding(1)
+            .setDescriptorType(vk::DescriptorType::eCombinedImageSampler)
+            .setDescriptorCount(texture_count)
+            .setStageFlags(vk::ShaderStageFlagBits::eFragment)
+            .setPImmutableSamplers(nullptr)};
+
+    auto const descriptor_layout = vk::DescriptorSetLayoutCreateInfo().setBindings(layout_bindings);
+
+    auto result = device.createDescriptorSetLayout(&descriptor_layout, nullptr, &desc_layout);
+    VERIFY(result == vk::Result::eSuccess);
+
+    auto const pPipelineLayoutCreateInfo = vk::PipelineLayoutCreateInfo().setSetLayouts(desc_layout);
+
+    result = device.createPipelineLayout(&pPipelineLayoutCreateInfo, nullptr, &pipeline_layout);
+    VERIFY(result == vk::Result::eSuccess);
+}
+
+void Demo::prepare_descriptor_pool() {
+    std::array<vk::DescriptorPoolSize, 2> const poolSizes = {
+        vk::DescriptorPoolSize()
+            .setType(vk::DescriptorType::eUniformBuffer)
+            .setDescriptorCount(static_cast<uint32_t>(submission_resources.size())),
+        vk::DescriptorPoolSize()
+            .setType(vk::DescriptorType::eCombinedImageSampler)
+            .setDescriptorCount(static_cast<uint32_t>(submission_resources.size()) * texture_count)};
+
+    auto const descriptor_pool =
+        vk::DescriptorPoolCreateInfo().setMaxSets(static_cast<uint32_t>(submission_resources.size())).setPoolSizes(poolSizes);
+
+    auto result = device.createDescriptorPool(&descriptor_pool, nullptr, &desc_pool);
+    VERIFY(result == vk::Result::eSuccess);
+}
+
+void Demo::prepare_descriptor_set() {
+    auto const alloc_info = vk::DescriptorSetAllocateInfo().setDescriptorPool(desc_pool).setSetLayouts(desc_layout);
+
+    auto buffer_info = vk::DescriptorBufferInfo().setOffset(0).setRange(sizeof(vktexcube_vs_uniform));
+
+    std::array<vk::DescriptorImageInfo, texture_count> tex_descs;
+    for (uint32_t i = 0; i < texture_count; i++) {
+        tex_descs[i].setSampler(textures[i].sampler);
+        tex_descs[i].setImageView(textures[i].view);
+        tex_descs[i].setImageLayout(vk::ImageLayout::eShaderReadOnlyOptimal);
+    }
+
+    std::array<vk::WriteDescriptorSet, 2> writes;
+    writes[0].setDescriptorCount(1).setDescriptorType(vk::DescriptorType::eUniformBuffer).setPBufferInfo(&buffer_info);
+    writes[1]
+        .setDstBinding(1)
+        .setDescriptorCount(texture_count)
+        .setDescriptorType(vk::DescriptorType::eCombinedImageSampler)
+        .setImageInfo(tex_descs);
+
+    for (auto &submission_resource : submission_resources) {
+        auto result = device.allocateDescriptorSets(&alloc_info, &submission_resource.descriptor_set);
+        VERIFY(result == vk::Result::eSuccess);
+
+        buffer_info.setBuffer(submission_resource.uniform_buffer);
+        writes[0].setDstSet(submission_resource.descriptor_set);
+        writes[1].setDstSet(submission_resource.descriptor_set);
+        device.updateDescriptorSets(writes, {});
+    }
+}
+
+void Demo::prepare_framebuffers() {
+    std::array<vk::ImageView, 2> attachments;
+    attachments[1] = depth.view;
+
+    for (auto &swapchain_image_resource : swapchain_resources) {
+        attachments[0] = swapchain_image_resource.view;
+        auto const framebuffer_return = device.createFramebuffer(vk::FramebufferCreateInfo()
+                                                                     .setRenderPass(render_pass)
+                                                                     .setAttachments(attachments)
+                                                                     .setWidth(width)
+                                                                     .setHeight(height)
+                                                                     .setLayers(1));
+        VERIFY(framebuffer_return.result == vk::Result::eSuccess);
+        swapchain_image_resource.framebuffer = framebuffer_return.value;
+    }
+}
+
+void Demo::prepare_submission_sync_objects() {
+    // Create semaphores to synchronize acquiring presentable buffers before
+    // rendering and waiting for drawing to be complete before presenting
+    auto const semaphoreCreateInfo = vk::SemaphoreCreateInfo();
+
+    // Create fences that we can use to throttle if we get too far
+    // ahead of the image presents
+    auto const fence_ci = vk::FenceCreateInfo().setFlags(vk::FenceCreateFlagBits::eSignaled);
+    for (auto &submission_resource : submission_resources) {
+        vk::Result result = device.createFence(&fence_ci, nullptr, &submission_resource.fence);
+        VERIFY(result == vk::Result::eSuccess);
+
+        result = device.createSemaphore(&semaphoreCreateInfo, nullptr, &submission_resource.image_acquired_semaphore);
+        VERIFY(result == vk::Result::eSuccess);
+    }
+}
+
+vk::ShaderModule Demo::prepare_fs() {
+    const uint32_t fragShaderCode[] = {
+#ifdef CUBE_FRAG_INC
+#include CUBE_FRAG_INC
+#else
+#include "cube.frag.inc"
+#endif
+    };
+
+    frag_shader_module = prepare_shader_module(fragShaderCode, sizeof(fragShaderCode));
+
+    return frag_shader_module;
+}
+
+void Demo::prepare_pipeline() {
+    vk::PipelineCacheCreateInfo const pipelineCacheInfo;
+    auto result = device.createPipelineCache(&pipelineCacheInfo, nullptr, &pipelineCache);
+    VERIFY(result == vk::Result::eSuccess);
+
+    std::array<vk::PipelineShaderStageCreateInfo, 2> const shaderStageInfo = {
+        vk::PipelineShaderStageCreateInfo().setStage(vk::ShaderStageFlagBits::eVertex).setModule(prepare_vs()).setPName("main"),
+        vk::PipelineShaderStageCreateInfo().setStage(vk::ShaderStageFlagBits::eFragment).setModule(prepare_fs()).setPName("main")};
+
+    vk::PipelineVertexInputStateCreateInfo const vertexInputInfo;
+
+    auto const inputAssemblyInfo = vk::PipelineInputAssemblyStateCreateInfo().setTopology(vk::PrimitiveTopology::eTriangleList);
+
+    // TODO: Where are pViewports and pScissors set?
+    auto const viewportInfo = vk::PipelineViewportStateCreateInfo().setViewportCount(1).setScissorCount(1);
+
+    auto const rasterizationInfo = vk::PipelineRasterizationStateCreateInfo()
+                                       .setDepthClampEnable(VK_FALSE)
+                                       .setRasterizerDiscardEnable(VK_FALSE)
+                                       .setPolygonMode(vk::PolygonMode::eFill)
+                                       .setCullMode(vk::CullModeFlagBits::eBack)
+                                       .setFrontFace(vk::FrontFace::eCounterClockwise)
+                                       .setDepthBiasEnable(VK_FALSE)
+                                       .setLineWidth(1.0f);
+
+    auto const multisampleInfo = vk::PipelineMultisampleStateCreateInfo();
+
+    auto const stencilOp =
+        vk::StencilOpState().setFailOp(vk::StencilOp::eKeep).setPassOp(vk::StencilOp::eKeep).setCompareOp(vk::CompareOp::eAlways);
+
+    auto const depthStencilInfo = vk::PipelineDepthStencilStateCreateInfo()
+                                      .setDepthTestEnable(VK_TRUE)
+                                      .setDepthWriteEnable(VK_TRUE)
+                                      .setDepthCompareOp(vk::CompareOp::eLessOrEqual)
+                                      .setDepthBoundsTestEnable(VK_FALSE)
+                                      .setStencilTestEnable(VK_FALSE)
+                                      .setFront(stencilOp)
+                                      .setBack(stencilOp);
+
+    std::array<vk::PipelineColorBlendAttachmentState, 1> const colorBlendAttachments = {
+        vk::PipelineColorBlendAttachmentState().setColorWriteMask(vk::ColorComponentFlagBits::eR | vk::ColorComponentFlagBits::eG |
+                                                                  vk::ColorComponentFlagBits::eB | vk::ColorComponentFlagBits::eA)};
+
+    auto const colorBlendInfo = vk::PipelineColorBlendStateCreateInfo().setAttachments(colorBlendAttachments);
+
+    std::array<vk::DynamicState, 2> const dynamicStates = {vk::DynamicState::eViewport, vk::DynamicState::eScissor};
+
+    auto const dynamicStateInfo = vk::PipelineDynamicStateCreateInfo().setDynamicStates(dynamicStates);
+
+    auto pipline_return = device.createGraphicsPipelines(pipelineCache, vk::GraphicsPipelineCreateInfo()
+                                                                            .setStages(shaderStageInfo)
+                                                                            .setPVertexInputState(&vertexInputInfo)
+                                                                            .setPInputAssemblyState(&inputAssemblyInfo)
+                                                                            .setPViewportState(&viewportInfo)
+                                                                            .setPRasterizationState(&rasterizationInfo)
+                                                                            .setPMultisampleState(&multisampleInfo)
+                                                                            .setPDepthStencilState(&depthStencilInfo)
+                                                                            .setPColorBlendState(&colorBlendInfo)
+                                                                            .setPDynamicState(&dynamicStateInfo)
+                                                                            .setLayout(pipeline_layout)
+                                                                            .setRenderPass(render_pass));
+    VERIFY(pipline_return.result == vk::Result::eSuccess);
+    pipeline = pipline_return.value.at(0);
+
+    device.destroyShaderModule(frag_shader_module);
+    device.destroyShaderModule(vert_shader_module);
+}
+
+void Demo::prepare_render_pass() {
+    // The initial layout for the color and depth attachments will be LAYOUT_UNDEFINED
+    // because at the start of the renderpass, we don't care about their contents.
+    // At the start of the subpass, the color attachment's layout will be transitioned
+    // to LAYOUT_COLOR_ATTACHMENT_OPTIMAL and the depth stencil attachment's layout
+    // will be transitioned to LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL.  At the end of
+    // the renderpass, the color attachment's layout will be transitioned to
+    // LAYOUT_PRESENT_SRC_KHR to be ready to present.  This is all done as part of
+    // the renderpass, no barriers are necessary.
+    std::array<vk::AttachmentDescription, 2> const attachments = {
+        vk::AttachmentDescription()
+            .setFormat(format)
+            .setSamples(vk::SampleCountFlagBits::e1)
+            .setLoadOp(vk::AttachmentLoadOp::eClear)
+            .setStoreOp(vk::AttachmentStoreOp::eStore)
+            .setStencilLoadOp(vk::AttachmentLoadOp::eDontCare)
+            .setStencilStoreOp(vk::AttachmentStoreOp::eDontCare)
+            .setInitialLayout(vk::ImageLayout::eUndefined)
+            .setFinalLayout(vk::ImageLayout::ePresentSrcKHR),
+        vk::AttachmentDescription()
+            .setFormat(depth.format)
+            .setSamples(vk::SampleCountFlagBits::e1)
+            .setLoadOp(vk::AttachmentLoadOp::eClear)
+            .setStoreOp(vk::AttachmentStoreOp::eDontCare)
+            .setStencilLoadOp(vk::AttachmentLoadOp::eDontCare)
+            .setStencilStoreOp(vk::AttachmentStoreOp::eDontCare)
+            .setInitialLayout(vk::ImageLayout::eUndefined)
+            .setFinalLayout(vk::ImageLayout::eDepthStencilAttachmentOptimal)};
+
+    auto const color_reference = vk::AttachmentReference().setAttachment(0).setLayout(vk::ImageLayout::eColorAttachmentOptimal);
+
+    auto const depth_reference =
+        vk::AttachmentReference().setAttachment(1).setLayout(vk::ImageLayout::eDepthStencilAttachmentOptimal);
+
+    auto const subpass = vk::SubpassDescription()
+                             .setPipelineBindPoint(vk::PipelineBindPoint::eGraphics)
+                             .setColorAttachments(color_reference)
+                             .setPDepthStencilAttachment(&depth_reference);
+
+    vk::PipelineStageFlags stages = vk::PipelineStageFlagBits::eEarlyFragmentTests | vk::PipelineStageFlagBits::eLateFragmentTests;
+    std::array<vk::SubpassDependency, 2> const dependencies = {
+        vk::SubpassDependency()  // Depth buffer is shared between swapchain images
+            .setSrcSubpass(VK_SUBPASS_EXTERNAL)
+            .setDstSubpass(0)
+            .setSrcStageMask(stages)
+            .setDstStageMask(stages)
+            .setSrcAccessMask(vk::AccessFlagBits::eDepthStencilAttachmentWrite)
+            .setDstAccessMask(vk::AccessFlagBits::eDepthStencilAttachmentRead | vk::AccessFlagBits::eDepthStencilAttachmentWrite)
+            .setDependencyFlags(vk::DependencyFlags()),
+        vk::SubpassDependency()  // Image layout transition
+            .setSrcSubpass(VK_SUBPASS_EXTERNAL)
+            .setDstSubpass(0)
+            .setSrcStageMask(vk::PipelineStageFlagBits::eColorAttachmentOutput)
+            .setDstStageMask(vk::PipelineStageFlagBits::eColorAttachmentOutput)
+            .setSrcAccessMask(vk::AccessFlagBits())
+            .setDstAccessMask(vk::AccessFlagBits::eColorAttachmentWrite | vk::AccessFlagBits::eColorAttachmentRead)
+            .setDependencyFlags(vk::DependencyFlags()),
+    };
+
+    const auto render_pass_result = device.createRenderPass(
+        vk::RenderPassCreateInfo().setAttachments(attachments).setSubpasses(subpass).setDependencies(dependencies));
+    VERIFY(render_pass_result.result == vk::Result::eSuccess);
+    render_pass = render_pass_result.value;
+}
+
+vk::ShaderModule Demo::prepare_shader_module(const uint32_t *code, size_t size) {
+    const auto shader_module_return = device.createShaderModule(vk::ShaderModuleCreateInfo().setCodeSize(size).setPCode(code));
+    VERIFY(shader_module_return.result == vk::Result::eSuccess);
+
+    return shader_module_return.value;
+}
+
+void Demo::prepare_texture_buffer(const char *filename, texture_object &tex_obj) {
+    vk::SubresourceLayout tex_layout;
+
+    if (!loadTexture(filename, nullptr, tex_layout, tex_obj.tex_width, tex_obj.tex_height)) {
+        ERR_EXIT("Failed to load textures", "Load Texture Failure");
+    }
+
+    auto const buffer_create_info = vk::BufferCreateInfo()
+                                        .setSize(tex_obj.tex_width * tex_obj.tex_height * 4)
+                                        .setUsage(vk::BufferUsageFlagBits::eTransferSrc)
+                                        .setSharingMode(vk::SharingMode::eExclusive);
+
+    auto result = device.createBuffer(&buffer_create_info, nullptr, &tex_obj.buffer);
+    VERIFY(result == vk::Result::eSuccess);
+
+    vk::MemoryRequirements mem_reqs;
+    device.getBufferMemoryRequirements(tex_obj.buffer, &mem_reqs);
+
+    tex_obj.mem_alloc.setAllocationSize(mem_reqs.size);
+    tex_obj.mem_alloc.setMemoryTypeIndex(0);
+
+    vk::MemoryPropertyFlags requirements = vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent;
+    auto pass = memory_type_from_properties(mem_reqs.memoryTypeBits, requirements, tex_obj.mem_alloc.memoryTypeIndex);
+    VERIFY(pass == true);
+
+    result = device.allocateMemory(&tex_obj.mem_alloc, nullptr, &(tex_obj.mem));
+    VERIFY(result == vk::Result::eSuccess);
+
+    result = device.bindBufferMemory(tex_obj.buffer, tex_obj.mem, 0);
+    VERIFY(result == vk::Result::eSuccess);
+
+    vk::SubresourceLayout layout;
+    layout.rowPitch = tex_obj.tex_width * 4;
+    auto data = device.mapMemory(tex_obj.mem, 0, tex_obj.mem_alloc.allocationSize);
+    VERIFY(data.result == vk::Result::eSuccess);
+
+    if (!loadTexture(filename, (uint8_t *)data.value, layout, tex_obj.tex_width, tex_obj.tex_height)) {
+        fprintf(stderr, "Error loading texture: %s\n", filename);
+    }
+
+    device.unmapMemory(tex_obj.mem);
+}
+
+void Demo::prepare_texture_image(const char *filename, texture_object &tex_obj, vk::ImageTiling tiling, vk::ImageUsageFlags usage,
+                                 vk::MemoryPropertyFlags required_props) {
+    vk::SubresourceLayout tex_layout;
+    if (!loadTexture(filename, nullptr, tex_layout, tex_obj.tex_width, tex_obj.tex_height)) {
+        ERR_EXIT("Failed to load textures", "Load Texture Failure");
+    }
+
+    auto const image_create_info = vk::ImageCreateInfo()
+                                       .setImageType(vk::ImageType::e2D)
+                                       .setFormat(vk::Format::eR8G8B8A8Srgb)
+                                       .setExtent({tex_obj.tex_width, tex_obj.tex_height, 1})
+                                       .setMipLevels(1)
+                                       .setArrayLayers(1)
+                                       .setSamples(vk::SampleCountFlagBits::e1)
+                                       .setTiling(tiling)
+                                       .setUsage(usage)
+                                       .setSharingMode(vk::SharingMode::eExclusive)
+                                       .setInitialLayout(vk::ImageLayout::ePreinitialized);
+
+    auto result = device.createImage(&image_create_info, nullptr, &tex_obj.image);
+    VERIFY(result == vk::Result::eSuccess);
+
+    vk::MemoryRequirements mem_reqs;
+    device.getImageMemoryRequirements(tex_obj.image, &mem_reqs);
+
+    tex_obj.mem_alloc.setAllocationSize(mem_reqs.size);
+    tex_obj.mem_alloc.setMemoryTypeIndex(0);
+
+    auto pass = memory_type_from_properties(mem_reqs.memoryTypeBits, required_props, tex_obj.mem_alloc.memoryTypeIndex);
+    VERIFY(pass == true);
+
+    result = device.allocateMemory(&tex_obj.mem_alloc, nullptr, &tex_obj.mem);
+    VERIFY(result == vk::Result::eSuccess);
+
+    result = device.bindImageMemory(tex_obj.image, tex_obj.mem, 0);
+    VERIFY(result == vk::Result::eSuccess);
+
+    if (required_props & vk::MemoryPropertyFlagBits::eHostVisible) {
+        auto const subres = vk::ImageSubresource().setAspectMask(vk::ImageAspectFlagBits::eColor).setMipLevel(0).setArrayLayer(0);
+        vk::SubresourceLayout layout;
+        device.getImageSubresourceLayout(tex_obj.image, &subres, &layout);
+
+        auto data = device.mapMemory(tex_obj.mem, 0, tex_obj.mem_alloc.allocationSize);
+        VERIFY(data.result == vk::Result::eSuccess);
+
+        if (!loadTexture(filename, (uint8_t *)data.value, layout, tex_obj.tex_width, tex_obj.tex_height)) {
+            fprintf(stderr, "Error loading texture: %s\n", filename);
+        }
+
+        device.unmapMemory(tex_obj.mem);
+    }
+
+    tex_obj.imageLayout = vk::ImageLayout::eShaderReadOnlyOptimal;
+}
+
+void Demo::prepare_textures() {
+    vk::Format const tex_format = vk::Format::eR8G8B8A8Srgb;
+    vk::FormatProperties props;
+    gpu.getFormatProperties(tex_format, &props);
+
+    for (uint32_t i = 0; i < texture_count; i++) {
+        if ((props.linearTilingFeatures & vk::FormatFeatureFlagBits::eSampledImage) && !use_staging_buffer) {
+            /* Device can texture using linear textures */
+            prepare_texture_image(tex_files[i], textures[i], vk::ImageTiling::eLinear, vk::ImageUsageFlagBits::eSampled,
+                                  vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent);
+            // Nothing in the pipeline needs to be complete to start, and don't allow fragment
+            // shader to run until layout transition completes
+            set_image_layout(textures[i].image, vk::ImageAspectFlagBits::eColor, vk::ImageLayout::ePreinitialized,
+                             textures[i].imageLayout, vk::AccessFlagBits(), vk::PipelineStageFlagBits::eTopOfPipe,
+                             vk::PipelineStageFlagBits::eFragmentShader);
+            staging_texture.image = vk::Image();
+        } else if (props.optimalTilingFeatures & vk::FormatFeatureFlagBits::eSampledImage) {
+            /* Must use staging buffer to copy linear texture to optimized */
+
+            prepare_texture_buffer(tex_files[i], staging_texture);
+
+            prepare_texture_image(tex_files[i], textures[i], vk::ImageTiling::eOptimal,
+                                  vk::ImageUsageFlagBits::eTransferDst | vk::ImageUsageFlagBits::eSampled,
+                                  vk::MemoryPropertyFlagBits::eDeviceLocal);
+
+            set_image_layout(textures[i].image, vk::ImageAspectFlagBits::eColor, vk::ImageLayout::ePreinitialized,
+                             vk::ImageLayout::eTransferDstOptimal, vk::AccessFlagBits(), vk::PipelineStageFlagBits::eTopOfPipe,
+                             vk::PipelineStageFlagBits::eTransfer);
+
+            auto const subresource = vk::ImageSubresourceLayers()
+                                         .setAspectMask(vk::ImageAspectFlagBits::eColor)
+                                         .setMipLevel(0)
+                                         .setBaseArrayLayer(0)
+                                         .setLayerCount(1);
+
+            auto const copy_region = vk::BufferImageCopy()
+                                         .setBufferOffset(0)
+                                         .setBufferRowLength(staging_texture.tex_width)
+                                         .setBufferImageHeight(staging_texture.tex_height)
+                                         .setImageSubresource(subresource)
+                                         .setImageOffset({0, 0, 0})
+                                         .setImageExtent({staging_texture.tex_width, staging_texture.tex_height, 1});
+
+            cmd.copyBufferToImage(staging_texture.buffer, textures[i].image, vk::ImageLayout::eTransferDstOptimal, 1, &copy_region);
+
+            set_image_layout(textures[i].image, vk::ImageAspectFlagBits::eColor, vk::ImageLayout::eTransferDstOptimal,
+                             textures[i].imageLayout, vk::AccessFlagBits::eTransferWrite, vk::PipelineStageFlagBits::eTransfer,
+                             vk::PipelineStageFlagBits::eFragmentShader);
+        } else {
+            assert(false && "No support for R8G8B8A8_SRGB as texture image format");
+        }
+
+        auto const samplerInfo = vk::SamplerCreateInfo()
+                                     .setMagFilter(vk::Filter::eNearest)
+                                     .setMinFilter(vk::Filter::eNearest)
+                                     .setMipmapMode(vk::SamplerMipmapMode::eNearest)
+                                     .setAddressModeU(vk::SamplerAddressMode::eClampToEdge)
+                                     .setAddressModeV(vk::SamplerAddressMode::eClampToEdge)
+                                     .setAddressModeW(vk::SamplerAddressMode::eClampToEdge)
+                                     .setMipLodBias(0.0f)
+                                     .setAnisotropyEnable(VK_FALSE)
+                                     .setMaxAnisotropy(1)
+                                     .setCompareEnable(VK_FALSE)
+                                     .setCompareOp(vk::CompareOp::eNever)
+                                     .setMinLod(0.0f)
+                                     .setMaxLod(0.0f)
+                                     .setBorderColor(vk::BorderColor::eFloatOpaqueWhite)
+                                     .setUnnormalizedCoordinates(VK_FALSE);
+
+        auto result = device.createSampler(&samplerInfo, nullptr, &textures[i].sampler);
+        VERIFY(result == vk::Result::eSuccess);
+
+        auto const viewInfo = vk::ImageViewCreateInfo()
+                                  .setImage(textures[i].image)
+                                  .setViewType(vk::ImageViewType::e2D)
+                                  .setFormat(tex_format)
+                                  .setSubresourceRange(vk::ImageSubresourceRange(vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1));
+
+        result = device.createImageView(&viewInfo, nullptr, &textures[i].view);
+        VERIFY(result == vk::Result::eSuccess);
+    }
+}
+
+vk::ShaderModule Demo::prepare_vs() {
+    const uint32_t vertShaderCode[] = {
+#ifdef CUBE_VERT_INC
+#include CUBE_VERT_INC
+#else
+#include "cube.vert.inc"
+#endif
+    };
+
+    vert_shader_module = prepare_shader_module(vertShaderCode, sizeof(vertShaderCode));
+
+    return vert_shader_module;
+}
+
+void Demo::resize() {
+    // Don't react to resize until after first initialization.
+    if (!initialized) {
+        return;
+    }
+
+    // Don't do anything if the surface has zero size, as vulkan disallows creating swapchains with zero area
+    // We use is_minimized to track this because zero size window usually occurs from minimizing
+    if (width == 0 || height == 0) {
+        is_minimized = true;
+        return;
+    } else {
+        is_minimized = false;
+    }
+
+    // In order to properly resize the window, we must re-create the
+    // swapchain
+    //
+    // First, destroy the old swapchain and its associated resources, setting swapchain_ready to false to prevent draw from
+    // running
+    if (swapchain_ready) {
+        swapchain_ready = false;
+        auto result = device.waitIdle();
+        VERIFY(result == vk::Result::eSuccess);
+
+        device.destroyImageView(depth.view);
+        device.destroyImage(depth.image);
+        device.freeMemory(depth.mem);
+        depth = {};
+
+        for (auto &swapchain_resource : swapchain_resources) {
+            device.destroyFramebuffer(swapchain_resource.framebuffer);
+            device.destroyImageView(swapchain_resource.view);
+            device.destroySemaphore(swapchain_resource.draw_complete_semaphore);
+            if (separate_present_queue) {
+                device.destroySemaphore(swapchain_resource.image_ownership_semaphore);
+            }
+        }
+        swapchain_resources.clear();
+    }
+    // Second, recreate the swapchain, depth buffer, and framebuffers.
+    prepare_swapchain();
+}
+
+void Demo::set_image_layout(vk::Image image, vk::ImageAspectFlags aspectMask, vk::ImageLayout oldLayout, vk::ImageLayout newLayout,
+                            vk::AccessFlags srcAccessMask, vk::PipelineStageFlags src_stages, vk::PipelineStageFlags dest_stages) {
+    assert(cmd);
+
+    auto DstAccessMask = [](vk::ImageLayout const &layout) {
+        vk::AccessFlags flags;
+
+        switch (layout) {
+            case vk::ImageLayout::eTransferDstOptimal:
+                // Make sure anything that was copying from this image has
+                // completed
+                flags = vk::AccessFlagBits::eTransferWrite;
+                break;
+            case vk::ImageLayout::eColorAttachmentOptimal:
+                flags = vk::AccessFlagBits::eColorAttachmentWrite;
+                break;
+            case vk::ImageLayout::eDepthStencilAttachmentOptimal:
+                flags = vk::AccessFlagBits::eDepthStencilAttachmentWrite;
+                break;
+            case vk::ImageLayout::eShaderReadOnlyOptimal:
+                // Make sure any Copy or CPU writes to image are flushed
+                flags = vk::AccessFlagBits::eShaderRead | vk::AccessFlagBits::eInputAttachmentRead;
+                break;
+            case vk::ImageLayout::eTransferSrcOptimal:
+                flags = vk::AccessFlagBits::eTransferRead;
+                break;
+            case vk::ImageLayout::ePresentSrcKHR:
+                flags = vk::AccessFlagBits::eMemoryRead;
+                break;
+            default:
+                break;
+        }
+
+        return flags;
+    };
+
+    cmd.pipelineBarrier(src_stages, dest_stages, vk::DependencyFlagBits(), {}, {},
+                        vk::ImageMemoryBarrier()
+                            .setSrcAccessMask(srcAccessMask)
+                            .setDstAccessMask(DstAccessMask(newLayout))
+                            .setOldLayout(oldLayout)
+                            .setNewLayout(newLayout)
+                            .setSrcQueueFamilyIndex(VK_QUEUE_FAMILY_IGNORED)
+                            .setDstQueueFamilyIndex(VK_QUEUE_FAMILY_IGNORED)
+                            .setImage(image)
+                            .setSubresourceRange(vk::ImageSubresourceRange(aspectMask, 0, 1, 0, 1)));
+}
+
+void Demo::update_data_buffer(void *uniform_memory_ptr) {
+    mat4x4 VP;
+    mat4x4_mul(VP, projection_matrix, view_matrix);
+
+    // Rotate around the Y axis
+    mat4x4 Model;
+    mat4x4_dup(Model, model_matrix);
+    mat4x4_rotate_Y(model_matrix, Model, static_cast<float>(degreesToRadians(spin_angle)));
+    mat4x4_orthonormalize(model_matrix, model_matrix);
+
+    mat4x4 MVP;
+    mat4x4_mul(MVP, VP, model_matrix);
+
+    memcpy(uniform_memory_ptr, (const void *)&MVP[0][0], sizeof(MVP));
+}
+
+/* Convert ppm image data from header file into RGBA texture image */
+#ifdef TEXTURE_PPM_H
+#include TEXTURE_PPM_H
+#else
+#include "lunarg.ppm.h"
+#endif
+bool Demo::loadTexture(const char *filename, uint8_t *rgba_data, vk::SubresourceLayout &layout, uint32_t &width, uint32_t &height) {
+    (void)filename;
+    char *cPtr;
+    cPtr = (char *)lunarg_ppm;
+    if ((unsigned char *)cPtr >= (lunarg_ppm + lunarg_ppm_len) || strncmp(cPtr, "P6\n", 3)) {
+        return false;
+    }
+    while (strncmp(cPtr++, "\n", 1));
+    sscanf(cPtr, "%u %u", &width, &height);
+    if (rgba_data == nullptr) {
+        return true;
+    }
+    while (strncmp(cPtr++, "\n", 1));
+    if ((unsigned char *)cPtr >= (lunarg_ppm + lunarg_ppm_len) || strncmp(cPtr, "255\n", 4)) {
+        return false;
+    }
+    while (strncmp(cPtr++, "\n", 1));
+    for (uint32_t y = 0; y < height; y++) {
+        uint8_t *rowPtr = rgba_data;
+        for (uint32_t x = 0; x < width; x++) {
+            memcpy(rowPtr, cPtr, 3);
+            rowPtr[3] = 255; /* Alpha of 1 */
+            rowPtr += 4;
+            cPtr += 3;
+        }
+        rgba_data += layout.rowPitch;
+    }
+    return true;
+}
+
+bool Demo::memory_type_from_properties(uint32_t typeBits, vk::MemoryPropertyFlags requirements_mask, uint32_t &typeIndex) {
+    // Search memtypes to find first index with those properties
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++) {
+        if ((typeBits & 1) == 1) {
+            // Type is available, does it match user properties?
+            if ((memory_properties.memoryTypes[i].propertyFlags & requirements_mask) == requirements_mask) {
+                typeIndex = i;
+                return true;
+            }
+        }
+        typeBits >>= 1;
+    }
+
+    // No memory types matched, return failure
+    return false;
+}
+
+vk::SurfaceFormatKHR Demo::pick_surface_format(const std::vector<vk::SurfaceFormatKHR> &surface_formats) {
+    // Prefer non-SRGB formats...
+    for (const auto &surface_format : surface_formats) {
+        const vk::Format format = surface_format.format;
+
+        if (format == vk::Format::eR8G8B8A8Unorm || format == vk::Format::eB8G8R8A8Unorm ||
+            format == vk::Format::eA2B10G10R10UnormPack32 || format == vk::Format::eA2R10G10B10UnormPack32 ||
+            format == vk::Format::eA1R5G5B5UnormPack16 || format == vk::Format::eR5G6B5UnormPack16 ||
+            format == vk::Format::eR16G16B16A16Sfloat) {
+            return surface_format;
+        }
+    }
+
+    printf("Can't find our preferred formats... Falling back to first exposed format. Rendering may be incorrect.\n");
+
+    assert(surface_formats.size() >= 1);
+    return surface_formats[0];
+}
+
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+template <>
+void Demo::run<WsiPlatform::win32>() {
+    if (!initialized || !swapchain_ready) {
+        return;
+    }
+
+    draw();
+    if (!is_minimized) {
+        curFrame++;
+    }
+
+    if (frameCount != UINT32_MAX && curFrame == frameCount) {
+        PostQuitMessage(validation_error);
+    }
+}
+
+template <>
+void Demo::create_window<WsiPlatform::win32>() {
+    WNDCLASSEX win_class;
+
+    // Initialize the window class structure:
+    win_class.cbSize = sizeof(WNDCLASSEX);
+    win_class.style = CS_HREDRAW | CS_VREDRAW;
+    win_class.lpfnWndProc = WndProc;
+    win_class.cbClsExtra = 0;
+    win_class.cbWndExtra = 0;
+    win_class.hInstance = connection;  // hInstance
+    win_class.hIcon = LoadIcon(nullptr, IDI_APPLICATION);
+    win_class.hCursor = LoadCursor(nullptr, IDC_ARROW);
+    win_class.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
+    win_class.lpszMenuName = nullptr;
+    win_class.lpszClassName = name.c_str();
+    win_class.hIconSm = LoadIcon(nullptr, IDI_WINLOGO);
+
+    // Register window class:
+    if (!RegisterClassEx(&win_class)) {
+        // It didn't work, so try to give a useful error:
+        printf("Unexpected error trying to start the application!\n");
+        fflush(stdout);
+        exit(1);
+    }
+
+    // Create window with the registered class:
+    RECT wr = {0, 0, static_cast<LONG>(width), static_cast<LONG>(height)};
+    AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);
+    window = CreateWindowEx(0,
+                            name.c_str(),          // class name
+                            name.c_str(),          // app name
+                            WS_OVERLAPPEDWINDOW |  // window style
+                                WS_VISIBLE | WS_SYSMENU,
+                            100, 100,            // x/y coords
+                            wr.right - wr.left,  // width
+                            wr.bottom - wr.top,  // height
+                            nullptr,             // handle to parent
+                            nullptr,             // handle to menu
+                            connection,          // hInstance
+                            nullptr);            // no extra parameters
+
+    if (!window) {
+        // It didn't work, so try to give a useful error:
+        printf("Cannot create a window in which to draw!\n");
+        fflush(stdout);
+        exit(1);
+    }
+
+    // Window client area size must be at least 1 pixel high, to prevent
+    // crash.
+    minsize.x = GetSystemMetrics(SM_CXMINTRACK);
+    minsize.y = GetSystemMetrics(SM_CYMINTRACK) + 1;
+}
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+
+template <>
+void Demo::create_window<WsiPlatform::xlib>() {
+    const char *display_envar = getenv("DISPLAY");
+    if (display_envar == nullptr || display_envar[0] == '\0') {
+        printf("Environment variable DISPLAY requires a valid value.\nExiting ...\n");
+        fflush(stdout);
+        exit(1);
+    }
+
+    XInitThreads();
+    xlib_display = XOpenDisplay(nullptr);
+    long visualMask = VisualScreenMask;
+    int numberOfVisuals;
+    XVisualInfo vInfoTemplate = {};
+    vInfoTemplate.screen = DefaultScreen(xlib_display);
+    XVisualInfo *visualInfo = XGetVisualInfo(xlib_display, visualMask, &vInfoTemplate, &numberOfVisuals);
+
+    Colormap colormap =
+        XCreateColormap(xlib_display, RootWindow(xlib_display, vInfoTemplate.screen), visualInfo->visual, AllocNone);
+
+    XSetWindowAttributes windowAttributes = {};
+    windowAttributes.colormap = colormap;
+    windowAttributes.background_pixel = 0xFFFFFFFF;
+    windowAttributes.border_pixel = 0;
+    windowAttributes.event_mask = KeyPressMask | KeyReleaseMask | StructureNotifyMask | ExposureMask;
+
+    xlib_window =
+        XCreateWindow(xlib_display, RootWindow(xlib_display, vInfoTemplate.screen), 0, 0, width, height, 0, visualInfo->depth,
+                      InputOutput, visualInfo->visual, CWBackPixel | CWBorderPixel | CWEventMask | CWColormap, &windowAttributes);
+
+    XSelectInput(xlib_display, xlib_window, ExposureMask | KeyPressMask);
+    XMapWindow(xlib_display, xlib_window);
+    XFlush(xlib_display);
+    xlib_wm_delete_window = XInternAtom(xlib_display, "WM_DELETE_WINDOW", False);
+    XSetWMProtocols(xlib_display, xlib_window, &xlib_wm_delete_window, 1);
+}
+
+void Demo::handle_xlib_event(const XEvent *event) {
+    switch (event->type) {
+        case ClientMessage:
+            if ((Atom)event->xclient.data.l[0] == xlib_wm_delete_window) {
+                quit = true;
+            }
+            break;
+        case KeyPress:
+            switch (event->xkey.keycode) {
+                case 0x9:  // Escape
+                    quit = true;
+                    break;
+                case 0x71:  // left arrow key
+                    spin_angle -= spin_increment;
+                    break;
+                case 0x72:  // right arrow key
+                    spin_angle += spin_increment;
+                    break;
+                case 0x41:  // space bar
+                    pause = !pause;
+                    break;
+            }
+            break;
+        case ConfigureNotify:
+            if (((int32_t)width != event->xconfigure.width) || ((int32_t)height != event->xconfigure.height)) {
+                width = event->xconfigure.width;
+                height = event->xconfigure.height;
+                resize();
+            }
+            break;
+        default:
+            break;
+    }
+}
+
+template <>
+void Demo::run<WsiPlatform::xlib>() {
+    while (!quit) {
+        XEvent event;
+
+        if (pause) {
+            XNextEvent(xlib_display, &event);
+            handle_xlib_event(&event);
+        }
+        while (XPending(xlib_display) > 0) {
+            XNextEvent(xlib_display, &event);
+            handle_xlib_event(&event);
+        }
+        if (initialized && swapchain_ready) {
+            draw();
+            if (!is_minimized) {
+                curFrame++;
+            }
+
+            if (frameCount != UINT32_MAX && curFrame == frameCount) {
+                quit = true;
+            }
+        }
+    }
+}
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+
+void Demo::handle_xcb_event(const xcb_generic_event_t *event) {
+    uint8_t event_code = event->response_type & 0x7f;
+    switch (event_code) {
+        case XCB_EXPOSE:
+            // TODO: Resize window
+            break;
+        case XCB_CLIENT_MESSAGE:
+            if ((*(xcb_client_message_event_t *)event).data.data32[0] == (*atom_wm_delete_window).atom) {
+                quit = true;
+            }
+            break;
+        case XCB_KEY_RELEASE: {
+            const xcb_key_release_event_t *key = (const xcb_key_release_event_t *)event;
+
+            switch (key->detail) {
+                case 0x9:  // Escape
+                    quit = true;
+                    break;
+                case 0x71:  // left arrow key
+                    spin_angle -= spin_increment;
+                    break;
+                case 0x72:  // right arrow key
+                    spin_angle += spin_increment;
+                    break;
+                case 0x41:  // space bar
+                    pause = !pause;
+                    break;
+            }
+        } break;
+        case XCB_CONFIGURE_NOTIFY: {
+            const xcb_configure_notify_event_t *cfg = (const xcb_configure_notify_event_t *)event;
+            if ((width != cfg->width) || (height != cfg->height)) {
+                width = cfg->width;
+                height = cfg->height;
+                resize();
+            }
+        } break;
+        default:
+            break;
+    }
+}
+
+template <>
+void Demo::run<WsiPlatform::xcb>() {
+    xcb_flush(connection);
+
+    while (!quit) {
+        xcb_generic_event_t *event;
+
+        if (pause) {
+            event = xcb_wait_for_event(connection);
+        } else {
+            event = xcb_poll_for_event(connection);
+        }
+        while (event) {
+            handle_xcb_event(event);
+            free(event);
+            event = xcb_poll_for_event(connection);
+        }
+        if (initialized && swapchain_ready) {
+            draw();
+            if (!is_minimized) {
+                curFrame++;
+            }
+            if (frameCount != UINT32_MAX && curFrame == frameCount) {
+                quit = true;
+            }
+        }
+    }
+}
+
+template <>
+void Demo::create_window<WsiPlatform::xcb>() {
+    uint32_t value_mask, value_list[32];
+
+    xcb_window = xcb_generate_id(connection);
+
+    value_mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
+    value_list[0] = screen->black_pixel;
+    value_list[1] = XCB_EVENT_MASK_KEY_RELEASE | XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_STRUCTURE_NOTIFY;
+
+    xcb_create_window(connection, XCB_COPY_FROM_PARENT, xcb_window, screen->root, 0, 0, width, height, 0,
+                      XCB_WINDOW_CLASS_INPUT_OUTPUT, screen->root_visual, value_mask, value_list);
+
+    /* Magic code that will send notification when window is destroyed */
+    xcb_intern_atom_cookie_t cookie = xcb_intern_atom(connection, 1, 12, "WM_PROTOCOLS");
+    xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(connection, cookie, 0);
+
+    xcb_intern_atom_cookie_t cookie2 = xcb_intern_atom(connection, 0, 16, "WM_DELETE_WINDOW");
+    atom_wm_delete_window = xcb_intern_atom_reply(connection, cookie2, 0);
+
+    xcb_change_property(connection, XCB_PROP_MODE_REPLACE, xcb_window, (*reply).atom, 4, 32, 1, &(*atom_wm_delete_window).atom);
+
+    free(reply);
+
+    xcb_map_window(connection, xcb_window);
+
+    // Force the x/y coordinates to 100,100 results are identical in
+    // consecutive
+    // runs
+    std::array<uint32_t, 2> const coords = {100, 100};
+    xcb_configure_window(connection, xcb_window, XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y, coords.data());
+}
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+
+template <>
+void Demo::run<WsiPlatform::wayland>() {
+    while (!quit) {
+        if (pause) {
+            wl_display_dispatch(wayland_display);
+        } else {
+            wl_display_dispatch_pending(wayland_display);
+            if (initialized && swapchain_ready) {
+                draw();
+                if (!is_minimized) {
+                    curFrame++;
+                }
+                if (frameCount != UINT32_MAX && curFrame == frameCount) {
+                    quit = true;
+                }
+            }
+        }
+    }
+}
+
+static void handle_surface_configure(void *data, xdg_surface *xdg_surface, uint32_t serial) {
+    Demo &demo = *static_cast<Demo *>(data);
+    xdg_surface_ack_configure(xdg_surface, serial);
+    demo.xdg_surface_has_been_configured = true;
+    if (demo.pending_width > 0) {
+        demo.width = demo.pending_width;
+    }
+    if (demo.pending_height > 0) {
+        demo.height = demo.pending_height;
+    }
+    demo.resize();
+}
+
+static const xdg_surface_listener surface_listener = {handle_surface_configure};
+
+static void handle_toplevel_configure(void *data, xdg_toplevel *xdg_toplevel, int32_t width, int32_t height,
+                                      struct wl_array *states) {
+    Demo &demo = *static_cast<Demo *>(data);
+    /* zero values imply the program may choose its own size, so in that case
+     * stay with the existing value (which on startup is the default) */
+    if (width > 0) {
+        demo.pending_width = static_cast<uint32_t>(width);
+    }
+    if (height > 0) {
+        demo.pending_height = static_cast<uint32_t>(height);
+    }
+    // This will be followed by a surface configure
+}
+
+static void handle_toplevel_close(void *data, xdg_toplevel *xdg_toplevel) {
+    Demo &demo = *static_cast<Demo *>(data);
+    demo.quit = true;
+}
+
+static const xdg_toplevel_listener toplevel_listener = {handle_toplevel_configure, handle_toplevel_close};
+
+template <>
+void Demo::create_window<WsiPlatform::wayland>() {
+    if (!wm_base) {
+        printf("Compositor did not provide the standard protocol xdg-wm-base\n");
+        fflush(stdout);
+        exit(1);
+    }
+
+    wayland_window = wl_compositor_create_surface(compositor);
+    if (!wayland_window) {
+        printf("Can not create wayland_surface from compositor!\n");
+        fflush(stdout);
+        exit(1);
+    }
+
+    window_surface = xdg_wm_base_get_xdg_surface(wm_base, wayland_window);
+    if (!window_surface) {
+        printf("Can not get xdg_surface from wayland_surface!\n");
+        fflush(stdout);
+        exit(1);
+    }
+    window_toplevel = xdg_surface_get_toplevel(window_surface);
+    if (!window_toplevel) {
+        printf("Can not allocate xdg_toplevel for xdg_surface!\n");
+        fflush(stdout);
+        exit(1);
+    }
+    xdg_surface_add_listener(window_surface, &surface_listener, this);
+    xdg_toplevel_add_listener(window_toplevel, &toplevel_listener, this);
+    xdg_toplevel_set_title(window_toplevel, APP_SHORT_NAME);
+    if (xdg_decoration_mgr) {
+        // if supported, let the compositor render titlebars for us
+        toplevel_decoration = zxdg_decoration_manager_v1_get_toplevel_decoration(xdg_decoration_mgr, window_toplevel);
+        zxdg_toplevel_decoration_v1_set_mode(toplevel_decoration, ZXDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE);
+    }
+
+    wl_surface_commit(wayland_window);
+}
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+
+void Demo::handle_directfb_event(const DFBInputEvent *event) {
+    if (event->type != DIET_KEYPRESS) return;
+    switch (event->key_symbol) {
+        case DIKS_ESCAPE:  // Escape
+            quit = true;
+            break;
+        case DIKS_CURSOR_LEFT:  // left arrow key
+            spin_angle -= spin_increment;
+            break;
+        case DIKS_CURSOR_RIGHT:  // right arrow key
+            spin_angle += spin_increment;
+            break;
+        case DIKS_SPACE:  // space bar
+            pause = !pause;
+            break;
+        default:
+            break;
+    }
+}
+
+template <>
+void Demo::run<WsiPlatform::directfb>() {
+    while (!quit) {
+        DFBInputEvent event;
+
+        if (pause) {
+            event_buffer->WaitForEvent(event_buffer);
+            if (!event_buffer->GetEvent(event_buffer, DFB_EVENT(&event))) handle_directfb_event(&event);
+        } else {
+            if (!event_buffer->GetEvent(event_buffer, DFB_EVENT(&event))) handle_directfb_event(&event);
+            if (initialized && swapchain_ready) {
+                draw();
+                if (!is_minimized) {
+                    curFrame++;
+                }
+                if (frameCount != UINT32_MAX && curFrame == frameCount) {
+                    quit = true;
+                }
+            }
+        }
+    }
+}
+
+template <>
+void Demo::create_window<WsiPlatform::directfb>() {
+    DFBResult ret;
+
+    ret = DirectFBInit(nullptr, nullptr);
+    if (ret) {
+        printf("DirectFBInit failed to initialize DirectFB!\n");
+        fflush(stdout);
+        exit(1);
+    }
+
+    ret = DirectFBCreate(&dfb);
+    if (ret) {
+        printf("DirectFBCreate failed to create main interface of DirectFB!\n");
+        fflush(stdout);
+        exit(1);
+    }
+
+    DFBSurfaceDescription desc;
+    desc.flags = (DFBSurfaceDescriptionFlags)(DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT);
+    desc.caps = DSCAPS_PRIMARY;
+    desc.width = width;
+    desc.height = height;
+    ret = dfb->CreateSurface(dfb, &desc, &directfb_window);
+    if (ret) {
+        printf("CreateSurface failed to create DirectFB surface interface!\n");
+        fflush(stdout);
+        exit(1);
+    }
+
+    ret = dfb->CreateInputEventBuffer(dfb, DICAPS_KEYS, DFB_FALSE, &event_buffer);
+    if (ret) {
+        printf("CreateInputEventBuffer failed to create DirectFB event buffer interface!\n");
+        fflush(stdout);
+        exit(1);
+    }
+}
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+template <>
+void Demo::run<WsiPlatform::metal>() {
+    if (!initialized || !swapchain_ready) {
+        return;
+    }
+    draw();
+    if (!is_minimized) {
+        curFrame++;
+    }
+    if (frameCount != UINT32_MAX && curFrame == frameCount) {
+        quit = true;
+    }
+}
+#endif
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+
+vk::Result Demo::create_display_surface() {
+    auto display_properties_return = gpu.getDisplayPropertiesKHR();
+    VERIFY((display_properties_return.result == vk::Result::eSuccess) ||
+           (display_properties_return.result == vk::Result::eIncomplete));
+
+    auto display = display_properties_return.value.at(0).display;
+
+    auto display_mode_props_return = gpu.getDisplayModePropertiesKHR(display);
+    VERIFY(display_mode_props_return.result == vk::Result::eSuccess);
+
+    if (display_mode_props_return.value.size() == 0) {
+        printf("Cannot find any mode for the display!\n");
+        fflush(stdout);
+        exit(1);
+    }
+    auto display_mode_prop = display_mode_props_return.value.at(0);
+
+    // Get the list of planes
+    auto display_plane_props_return = gpu.getDisplayPlanePropertiesKHR();
+    VERIFY(display_plane_props_return.result == vk::Result::eSuccess);
+
+    if (display_plane_props_return.value.size() == 0) {
+        printf("Cannot find any plane!\n");
+        fflush(stdout);
+        exit(1);
+    }
+    auto display_plane_props = display_plane_props_return.value;
+
+    vk::Bool32 found_plane = VK_FALSE;
+    uint32_t plane_found = 0;
+    // Find a plane compatible with the display
+    for (uint32_t plane_index = 0; plane_index < display_plane_props.size(); plane_index++) {
+        // Disqualify planes that are bound to a different display
+        if (display_plane_props[plane_index].currentDisplay && (display_plane_props[plane_index].currentDisplay != display)) {
+            continue;
+        }
+
+        auto display_plane_supported_displays_return = gpu.getDisplayPlaneSupportedDisplaysKHR(plane_index);
+        VERIFY(display_plane_supported_displays_return.result == vk::Result::eSuccess);
+
+        if (display_plane_supported_displays_return.value.size() == 0) {
+            continue;
+        }
+
+        for (const auto &supported_display : display_plane_supported_displays_return.value) {
+            if (supported_display == display) {
+                found_plane = VK_TRUE;
+                plane_found = plane_index;
+                break;
+            }
+        }
+
+        if (found_plane) {
+            break;
+        }
+    }
+
+    if (!found_plane) {
+        printf("Cannot find a plane compatible with the display!\n");
+        fflush(stdout);
+        exit(1);
+    }
+
+    vk::DisplayPlaneCapabilitiesKHR planeCaps =
+        gpu.getDisplayPlaneCapabilitiesKHR(display_mode_prop.displayMode, plane_found).value;
+    // Find a supported alpha mode
+    vk::DisplayPlaneAlphaFlagBitsKHR alphaMode = vk::DisplayPlaneAlphaFlagBitsKHR::eOpaque;
+    std::array<vk::DisplayPlaneAlphaFlagBitsKHR, 4> alphaModes = {
+        vk::DisplayPlaneAlphaFlagBitsKHR::eOpaque,
+        vk::DisplayPlaneAlphaFlagBitsKHR::eGlobal,
+        vk::DisplayPlaneAlphaFlagBitsKHR::ePerPixel,
+        vk::DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied,
+    };
+    for (const auto &alpha_mode : alphaModes) {
+        if (planeCaps.supportedAlpha & alpha_mode) {
+            alphaMode = alpha_mode;
+            break;
+        }
+    }
+
+    vk::Extent2D image_extent{};
+    image_extent.setWidth(display_mode_prop.parameters.visibleRegion.width)
+        .setHeight(display_mode_prop.parameters.visibleRegion.height);
+
+    auto const createInfo = vk::DisplaySurfaceCreateInfoKHR()
+                                .setDisplayMode(display_mode_prop.displayMode)
+                                .setPlaneIndex(plane_found)
+                                .setPlaneStackIndex(display_plane_props[plane_found].currentStackIndex)
+                                .setGlobalAlpha(1.0f)
+                                .setAlphaMode(alphaMode)
+                                .setImageExtent(image_extent);
+
+    return inst.createDisplayPlaneSurfaceKHR(&createInfo, nullptr, &surface);
+}
+
+template <>
+void Demo::run<WsiPlatform::display>() {
+    while (!quit) {
+        draw();
+        curFrame++;
+
+        if (frameCount != UINT32_MAX && curFrame == frameCount) {
+            quit = true;
+        }
+    }
+}
+
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+#include <sys/keycodes.h>
+
+template <>
+void Demo::run<WsiPlatform::qnx>() {
+    int size[2] = {0, 0};
+    screen_window_t win;
+    int val;
+    int rc;
+
+    while (!quit) {
+        while (!screen_get_event(screen_context, screen_event, pause ? ~0 : 0)) {
+            rc = screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE, &val);
+            if (rc) {
+                printf("Cannot get SCREEN_PROPERTY_TYPE of the event! (%s)\n", strerror(errno));
+                fflush(stdout);
+                quit = true;
+                break;
+            }
+            if (val == SCREEN_EVENT_NONE) {
+                break;
+            }
+            switch (val) {
+                case SCREEN_EVENT_KEYBOARD:
+                    rc = screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_FLAGS, &val);
+                    if (rc) {
+                        printf("Cannot get SCREEN_PROPERTY_FLAGS of the event! (%s)\n", strerror(errno));
+                        fflush(stdout);
+                        quit = true;
+                        break;
+                    }
+                    if (val & KEY_DOWN) {
+                        rc = screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_SYM, &val);
+                        if (rc) {
+                            printf("Cannot get SCREEN_PROPERTY_SYM of the event! (%s)\n", strerror(errno));
+                            fflush(stdout);
+                            quit = true;
+                            break;
+                        }
+                        switch (val) {
+                            case KEYCODE_ESCAPE:
+                                quit = true;
+                                break;
+                            case KEYCODE_SPACE:
+                                pause = !pause;
+                                break;
+                            case KEYCODE_LEFT:
+                                spin_angle -= spin_increment;
+                                break;
+                            case KEYCODE_RIGHT:
+                                spin_angle += spin_increment;
+                                break;
+                            default:
+                                break;
+                        }
+                    }
+                    break;
+                case SCREEN_EVENT_PROPERTY:
+                    rc = screen_get_event_property_pv(screen_event, SCREEN_PROPERTY_WINDOW, (void **)&win);
+                    if (rc) {
+                        printf("Cannot get SCREEN_PROPERTY_WINDOW of the event! (%s)\n", strerror(errno));
+                        fflush(stdout);
+                        quit = true;
+                        break;
+                    }
+                    rc = screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_NAME, &val);
+                    if (rc) {
+                        printf("Cannot get SCREEN_PROPERTY_NAME of the event! (%s)\n", strerror(errno));
+                        fflush(stdout);
+                        quit = true;
+                        break;
+                    }
+                    if (win == screen_window) {
+                        switch (val) {
+                            case SCREEN_PROPERTY_SIZE:
+                                rc = screen_get_window_property_iv(win, SCREEN_PROPERTY_SIZE, size);
+                                if (rc) {
+                                    printf("Cannot get SCREEN_PROPERTY_SIZE of the window in the event! (%s)\n", strerror(errno));
+                                    fflush(stdout);
+                                    quit = true;
+                                    break;
+                                }
+                                width = size[0];
+                                height = size[1];
+                                resize();
+                                break;
+                            default:
+                                /* We are not interested in any other events for now */
+                                break;
+                        }
+                    }
+                    break;
+            }
+        }
+
+        if (pause || !initialized || !swapchain_ready) {
+        } else {
+            update_data_buffer(submission_resources[current_submission_index].uniform_memory_ptr);
+            draw();
+            if (!is_minimized) {
+                curFrame++;
+            }
+            if (frameCount != UINT32_MAX && curFrame == frameCount) {
+                quit = true;
+            }
+        }
+    }
+}
+
+template <>
+void Demo::create_window<WsiPlatform::qnx>() {
+    const char *idstr = APP_SHORT_NAME;
+    int size[2];
+    int usage = SCREEN_USAGE_VULKAN;
+    int rc;
+
+    rc = screen_create_context(&screen_context, 0);
+    if (rc) {
+        printf("Cannot create QNX Screen context!\n");
+        fflush(stdout);
+        exit(EXIT_FAILURE);
+    }
+    rc = screen_create_window(&screen_window, screen_context);
+    if (rc) {
+        printf("Cannot create QNX Screen window!\n");
+        fflush(stdout);
+        exit(EXIT_FAILURE);
+    }
+    rc = screen_create_event(&screen_event);
+    if (rc) {
+        printf("Cannot create QNX Screen event!\n");
+        fflush(stdout);
+        exit(EXIT_FAILURE);
+    }
+
+    /* Set window caption */
+    screen_set_window_property_cv(screen_window, SCREEN_PROPERTY_ID_STRING, strlen(idstr), idstr);
+
+    /* Setup VULKAN usage flags */
+    rc = screen_set_window_property_iv(screen_window, SCREEN_PROPERTY_USAGE, &usage);
+    if (rc) {
+        printf("Cannot set SCREEN_USAGE_VULKAN flag!\n");
+        fflush(stdout);
+        exit(EXIT_FAILURE);
+    }
+
+    /* Setup window size */
+    if ((width == 0) || (height == 0)) {
+        rc = screen_get_window_property_iv(screen_window, SCREEN_PROPERTY_SIZE, size);
+        if (rc) {
+            printf("Cannot obtain current window size!\n");
+            fflush(stdout);
+            exit(EXIT_FAILURE);
+        }
+        width = size[0];
+        height = size[1];
+    } else {
+        size[0] = width;
+        size[1] = height;
+        rc = screen_set_window_property_iv(screen_window, SCREEN_PROPERTY_SIZE, size);
+        if (rc) {
+            printf("Cannot set window size!\n");
+            fflush(stdout);
+            exit(EXIT_FAILURE);
+        }
+    }
+}
+#endif
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+
+const char *Demo::get_fuchsia_image_pipe_layer() const {
+    switch (wsi_platform) {
+        case (WsiPlatform::fuchsia_display):
+            return "VK_LAYER_FUCHSIA_imagepipe_swapchain_fb";
+        case (WsiPlatform::fuchsia_scenic):
+            return "VK_LAYER_FUCHSIA_imagepipe_swapchain";
+        case (WsiPlatform::auto_):
+            ERR_EXIT("auto WSI platform is not supported on Fuchsia", "get_fuchsia_image_pipe_layer failure");
+        default:
+            ERR_EXIT("Invalid WSI platform", "get_fuchsia_image_pipe_layer failure");
+    }
+}
+
+void Demo::create_window<WsiPlatform::fuchsia_display>() {
+    // Nothing to do
+}
+
+void Demo::create_window<WsiPlatform::fuchsia_scenic>() {
+    if (flatland_view) return;
+
+    zx::result<fidl::ClientEnd<fuchsia_io::Directory> > incoming_result = component::OpenServiceRoot();
+    if (incoming_result.is_error()) {
+        printf("Failed to open incoming directory: %s\n", incoming_result.status_string());
+        ERR_EXIT("Failed to open incoming directory", "create_window<WsiPlatform::fuchsia_scenic> failure");
+    }
+    incoming = std::move(incoming_result).value();
+
+    outgoing = std::make_unique<component::OutgoingDirectory>(loop.dispatcher());
+
+    FlatlandViewProviderService::CreateView2Callback create_view_callback = [this](fuchsia_ui_app::CreateView2Args args) {
+        auto resize_callback = [this](uint32_t width, uint32_t height) {
+            this->width = width;
+            this->height = height;
+            if (initialized) {
+                resize();
+            }
+        };
+
+        flatland_view =
+            FlatlandView::Create(incoming.borrow(), std::move(*args.view_creation_token()), resize_callback, loop.dispatcher());
+        if (!flatland_view) ERR_EXIT("Failed to created FlatlandView", "create_window<WsiPlatform::fuchsia_scenic> failure");
+
+        view_creation_token = flatland_view->TakeChildViewCreationToken();
+    };
+
+    view_provider_service = std::make_unique<FlatlandViewProviderService>(std::move(create_view_callback), loop.dispatcher());
+
+    zx::result<> add_protocol_result = outgoing->AddUnmanagedProtocol<fuchsia_ui_app::ViewProvider>(
+        [view_provider_service = view_provider_service.get()](fidl::ServerEnd<fuchsia_ui_app::ViewProvider> server_end) {
+            view_provider_service->HandleViewProviderRequest(std::move(server_end));
+        });
+    if (add_protocol_result.is_error()) {
+        printf("Failed to add protocol to outgoing directory: %s\n", add_protocol_result.status_string());
+        ERR_EXIT("Failed to add protocol to outgoing directory", "create_window<WsiPlatform::fuchsia_scenic> failure");
+    }
+
+    zx::result<> serve_result = outgoing->ServeFromStartupInfo();
+    if (serve_result.is_error()) {
+        printf("Failed to serve outgoing directory: %s\n", serve_result.status_string());
+        ERR_EXIT("Failed to serve outgoing directory", "create_window<WsiPlatform::fuchsia_scenic> failure");
+    }
+
+    zx_status_t loop_status = ZX_OK;
+
+    // Run message loop until view has been created.
+    while (!quit && !flatland_view && loop_status == ZX_OK) {
+        loop_status = loop.RunUntilIdle();
+    }
+}
+template <>
+void Demo::run<WsiPlatform::fuchsia_display>() {
+    uint32_t num_frames = 60;
+    uint32_t elapsed_frames = 0;
+    static const float kMsPerSec = 1000;
+
+    double total_ms = 0;
+    auto t0 = std::chrono::high_resolution_clock::now();
+
+    while (!quit) {
+        if (wsi_platform == WsiPlatform::fuchsia_scenic) {
+            if (loop.RunUntilIdle() != ZX_OK) {
+                break;
+            }
+        }
+        auto t1 = std::chrono::high_resolution_clock::now();
+        std::chrono::duration<double, std::milli> elapsed = t1 - t0;
+        total_ms += elapsed.count();
+        t0 = t1;
+
+        if (elapsed_frames && (elapsed_frames % num_frames) == 0) {
+            float fps = static_cast<float>(num_frames / (total_ms / kMsPerSec));
+            printf("Framerate average for last %u frames: %f frames per second\n", num_frames, fps);
+            fflush(stdout);
+            total_ms = 0;
+            // attempt to log once per second
+            num_frames = static_cast<uint32_t>(fps);
+            elapsed_frames = 0;
+        }
+        if (initialized && swapchain_ready) {
+            draw();
+
+            if (!is_minimized) {
+                curFrame++;
+            }
+            elapsed_frames++;
+
+            if (frameCount != UINT32_MAX && curFrame == frameCount) {
+                quit = true;
+            }
+        }
+    }
+}
+
+template <>
+void Demo::run<WsiPlatform::fuchsia_scenic>() {
+    // Uses the same run function,as fuchsia_display
+    run<WsiPlatform::fuschia_display>();
+}
+
+#endif
+
+#if _WIN32
+// Include header required for parsing the command line options.
+#include <shellapi.h>
+
+Demo demo;
+
+// MS-Windows event handling function:
+LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
+    switch (uMsg) {
+        case WM_CLOSE:
+            PostQuitMessage(validation_error);
+            break;
+        case WM_PAINT:
+            if (!demo.in_callback) {
+                demo.run<WsiPlatform::win32>();
+            }
+            break;
+        case WM_GETMINMAXINFO:  // set window's minimum size
+            ((MINMAXINFO *)lParam)->ptMinTrackSize = demo.minsize;
+            return 0;
+        case WM_ERASEBKGND:
+            return 1;
+        case WM_SIZE:
+            // Resize the application to the new window size, except when
+            // it was minimized. Vulkan doesn't support images or swapchains
+            // with width=0 and height=0.
+            if (wParam != SIZE_MINIMIZED) {
+                demo.width = lParam & 0xffff;
+                demo.height = (lParam & 0xffff0000) >> 16;
+                demo.resize();
+            }
+            break;
+        case WM_KEYDOWN:
+            switch (wParam) {
+                case VK_ESCAPE:
+                    PostQuitMessage(validation_error);
+                    break;
+                case VK_LEFT:
+                    demo.spin_angle -= demo.spin_increment;
+                    break;
+                case VK_RIGHT:
+                    demo.spin_angle += demo.spin_increment;
+                    break;
+                case VK_SPACE:
+                    demo.pause = !demo.pause;
+                    break;
+            }
+            return 0;
+        default:
+            break;
+    }
+
+    return (DefWindowProc(hWnd, uMsg, wParam, lParam));
+}
+
+int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR pCmdLine, int nCmdShow) {
+    // TODO: Gah.. refactor. This isn't 1989.
+    MSG msg;    // message
+    bool done;  // flag saying when app is complete
+    int argc;
+    char **argv;
+
+    // Ensure wParam is initialized.
+    msg.wParam = 0;
+
+    // Use the CommandLine functions to get the command line arguments.
+    // Unfortunately, Microsoft outputs
+    // this information as wide characters for Unicode, and we simply want the
+    // Ascii version to be compatible
+    // with the non-Windows side.  So, we have to convert the information to
+    // Ascii character strings.
+    LPWSTR *commandLineArgs = CommandLineToArgvW(GetCommandLineW(), &argc);
+    if (nullptr == commandLineArgs) {
+        argc = 0;
+    }
+
+    if (argc > 0) {
+        argv = (char **)malloc(sizeof(char *) * argc);
+        if (argv == nullptr) {
+            argc = 0;
+        } else {
+            for (int iii = 0; iii < argc; iii++) {
+                size_t wideCharLen = wcslen(commandLineArgs[iii]);
+                size_t numConverted = 0;
+
+                argv[iii] = (char *)malloc(sizeof(char) * (wideCharLen + 1));
+                if (argv[iii] != nullptr) {
+                    wcstombs_s(&numConverted, argv[iii], wideCharLen + 1, commandLineArgs[iii], wideCharLen + 1);
+                }
+            }
+        }
+    } else {
+        argv = nullptr;
+    }
+
+    demo.init(argc, argv);
+
+    // Free up the items we had to allocate for the command line arguments.
+    if (argc > 0 && argv != nullptr) {
+        for (int iii = 0; iii < argc; iii++) {
+            if (argv[iii] != nullptr) {
+                free(argv[iii]);
+            }
+        }
+        free(argv);
+    }
+
+    demo.connection = hInstance;
+    demo.name = "Vulkan Cube";
+    demo.create_window<WsiPlatform::win32>();
+    demo.create_surface();
+    demo.select_physical_device();
+    demo.init_vk_swapchain();
+
+    demo.prepare();
+
+    done = false;  // initialize loop condition variable
+
+    // main message loop
+    while (!done) {
+        if (demo.pause) {
+            const BOOL succ = WaitMessage();
+
+            if (!succ) {
+                const auto &suppress_popups = demo.suppress_popups;
+                ERR_EXIT("WaitMessage() failed on paused demo", "event loop error");
+            }
+        }
+
+        PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE);
+        if (msg.message == WM_QUIT)  // check for a quit message
+        {
+            done = true;  // if found, quit app
+        } else {
+            /* Translate and dispatch to event queue*/
+            TranslateMessage(&msg);
+            DispatchMessage(&msg);
+        }
+        RedrawWindow(demo.window, nullptr, nullptr, RDW_INTERNALPAINT);
+    }
+
+    demo.cleanup();
+
+    return static_cast<int>(msg.wParam);
+}
+
+#elif defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__QNX__) || defined(__GNU__) || \
+    defined(__Fuchsia__)
+
+template <WsiPlatform WSI_PLATFORM>
+void Demo::execute() {
+    create_window<WSI_PLATFORM>();
+
+    create_surface();
+
+    select_physical_device();
+
+    init_vk_swapchain();
+
+    prepare();
+
+    run<WSI_PLATFORM>();
+}
+
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+template <>
+void Demo::execute<WsiPlatform::display>() {
+    select_physical_device();
+
+    create_surface();
+
+    init_vk_swapchain();
+
+    prepare();
+
+    run<WsiPlatform::display>();
+}
+#endif
+
+int main(int argc, char **argv) {
+    Demo demo;
+
+    demo.init(argc, argv);
+
+    switch (demo.wsi_platform) {
+        default:
+        case (WsiPlatform::auto_):
+            fprintf(stderr,
+                    "WSI platform should have already been set, indicating a bug. Please set a WSI platform manually with "
+                    "--wsi\n");
+            exit(1);
+            break;
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+        case (WsiPlatform::xcb):
+            demo.execute<WsiPlatform::xcb>();
+            break;
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+        case (WsiPlatform::xlib):
+            demo.execute<WsiPlatform::xlib>();
+            break;
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+        case (WsiPlatform::wayland):
+            demo.execute<WsiPlatform::wayland>();
+            break;
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+        case (WsiPlatform::directfb):
+            demo.execute<WsiPlatform::directfb>();
+            break;
+#endif
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+        case (WsiPlatform::display):
+            demo.execute<WsiPlatform::display>();
+            break;
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+        case (WsiPlatform::qnx):
+            demo.execute<WsiPlatform::qnx>();
+            break;
+#endif
+#if defined(VK_USE_PLATFORM_FUCHSIA)
+        case (WsiPlatform::fuchsia_display):
+            demo.execute<WsiPlatform::fuchsia_display>();
+            break;
+        case (WsiPlatform::fuchsia_scenic):
+            demo.execute<WsiPlatform::fuchsia_scenic>();
+            break;
+#endif
+    }
+
+    demo.cleanup();
+
+    return validation_error;
+}
+
+#elif defined(VK_USE_PLATFORM_METAL_EXT)
+
+// Global function invoked from NS or UI views and controllers to create demo
+static void demo_main(Demo &demo, void *caMetalLayer, int argc, const char *argv[]) {
+    demo.init(argc, (char **)argv);
+    demo.caMetalLayer = caMetalLayer;
+    demo.create_surface();
+    demo.select_physical_device();
+    demo.init_vk_swapchain();
+    demo.prepare();
+    demo.spin_angle = 0.4f;
+}
+
+#else
+#error "Platform not supported"
+#endif
diff --git a/tools/Vulkan-Tools/cube/cube.frag b/tools/Vulkan-Tools/cube/cube.frag
new file mode 100644
index 00000000..c68b9854
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/cube.frag
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2015-2016 The Khronos Group Inc.
+ * Copyright (c) 2015-2016 Valve Corporation
+ * Copyright (c) 2015-2016 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*
+ * Fragment shader for cube demo
+ */
+#version 400
+#extension GL_ARB_separate_shader_objects : enable
+#extension GL_ARB_shading_language_420pack : enable
+layout (binding = 1) uniform sampler2D tex;
+
+layout (location = 0) in vec4 texcoord;
+layout (location = 1) in vec3 frag_pos;
+layout (location = 0) out vec4 uFragColor;
+
+const vec3 lightDir= vec3(0.424, 0.566, 0.707);
+
+float linearToSrgb(float linear) {
+   if (linear <= 0.0031308) {
+      return linear * 12.92;
+   } else {
+      return (1.055 * pow(linear, 1.0/2.4)) - 0.055;
+   }
+}
+
+vec3 linearToSrgb(vec3 linear) {
+   return vec3(linearToSrgb(linear.r), linearToSrgb(linear.g), linearToSrgb(linear.b));
+}
+
+vec4 linearToSrgb(vec4 linear) {
+   return vec4(linearToSrgb(linear.rgb), linear.a);
+}
+
+void main() {
+   vec3 dX = dFdx(frag_pos);
+   vec3 dY = dFdy(frag_pos);
+   vec3 normal = normalize(cross(dX,dY));
+   float light = max(0.0, dot(lightDir, normal));
+   uFragColor = linearToSrgb(light * texture(tex, texcoord.xy));
+}
diff --git a/tools/Vulkan-Tools/cube/cube.frag.inc b/tools/Vulkan-Tools/cube/cube.frag.inc
new file mode 100644
index 00000000..539636e5
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/cube.frag.inc
@@ -0,0 +1,84 @@
+	// 1115.1.0
+	0x07230203,0x00010000,0x0008000b,0x00000073,0x00000000,0x00020011,0x00000001,0x0006000b,
+	0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001,
+	0x0008000f,0x00000004,0x00000004,0x6e69616d,0x00000000,0x0000004e,0x00000063,0x0000006b,
+	0x00030010,0x00000004,0x00000007,0x00030003,0x00000002,0x00000190,0x00090004,0x415f4c47,
+	0x735f4252,0x72617065,0x5f657461,0x64616873,0x6f5f7265,0x63656a62,0x00007374,0x00090004,
+	0x415f4c47,0x735f4252,0x69646168,0x6c5f676e,0x75676e61,0x5f656761,0x70303234,0x006b6361,
+	0x00040005,0x00000004,0x6e69616d,0x00000000,0x00070005,0x0000000a,0x656e696c,0x6f547261,
+	0x62677253,0x3b316628,0x00000000,0x00040005,0x00000009,0x656e696c,0x00007261,0x00070005,
+	0x00000010,0x656e696c,0x6f547261,0x62677253,0x33667628,0x0000003b,0x00040005,0x0000000f,
+	0x656e696c,0x00007261,0x00070005,0x00000016,0x656e696c,0x6f547261,0x62677253,0x34667628,
+	0x0000003b,0x00040005,0x00000015,0x656e696c,0x00007261,0x00040005,0x0000002c,0x61726170,
+	0x0000006d,0x00040005,0x00000032,0x61726170,0x0000006d,0x00040005,0x00000037,0x61726170,
+	0x0000006d,0x00040005,0x0000003f,0x61726170,0x0000006d,0x00030005,0x0000004c,0x00005864,
+	0x00050005,0x0000004e,0x67617266,0x736f705f,0x00000000,0x00030005,0x00000051,0x00005964,
+	0x00040005,0x00000054,0x6d726f6e,0x00006c61,0x00040005,0x00000059,0x6867696c,0x00000074,
+	0x00050005,0x00000063,0x61724675,0x6c6f4367,0x0000726f,0x00030005,0x00000068,0x00786574,
+	0x00050005,0x0000006b,0x63786574,0x64726f6f,0x00000000,0x00040005,0x00000071,0x61726170,
+	0x0000006d,0x00040047,0x0000004e,0x0000001e,0x00000001,0x00040047,0x00000063,0x0000001e,
+	0x00000000,0x00040047,0x00000068,0x00000021,0x00000001,0x00040047,0x00000068,0x00000022,
+	0x00000000,0x00040047,0x0000006b,0x0000001e,0x00000000,0x00020013,0x00000002,0x00030021,
+	0x00000003,0x00000002,0x00030016,0x00000006,0x00000020,0x00040020,0x00000007,0x00000007,
+	0x00000006,0x00040021,0x00000008,0x00000006,0x00000007,0x00040017,0x0000000c,0x00000006,
+	0x00000003,0x00040020,0x0000000d,0x00000007,0x0000000c,0x00040021,0x0000000e,0x0000000c,
+	0x0000000d,0x00040017,0x00000012,0x00000006,0x00000004,0x00040020,0x00000013,0x00000007,
+	0x00000012,0x00040021,0x00000014,0x00000012,0x00000013,0x0004002b,0x00000006,0x00000019,
+	0x3b4d2e1c,0x00020014,0x0000001a,0x0004002b,0x00000006,0x0000001f,0x414eb852,0x0004002b,
+	0x00000006,0x00000023,0x3f870a3d,0x0004002b,0x00000006,0x00000025,0x3ed55555,0x0004002b,
+	0x00000006,0x00000028,0x3d6147ae,0x00040015,0x0000002d,0x00000020,0x00000000,0x0004002b,
+	0x0000002d,0x0000002e,0x00000000,0x0004002b,0x0000002d,0x00000033,0x00000001,0x0004002b,
+	0x0000002d,0x00000038,0x00000002,0x0004002b,0x0000002d,0x00000043,0x00000003,0x00040020,
+	0x0000004d,0x00000001,0x0000000c,0x0004003b,0x0000004d,0x0000004e,0x00000001,0x0004002b,
+	0x00000006,0x0000005a,0x00000000,0x0004002b,0x00000006,0x0000005b,0x3ed91687,0x0004002b,
+	0x00000006,0x0000005c,0x3f10e560,0x0004002b,0x00000006,0x0000005d,0x3f34fdf4,0x0006002c,
+	0x0000000c,0x0000005e,0x0000005b,0x0000005c,0x0000005d,0x00040020,0x00000062,0x00000003,
+	0x00000012,0x0004003b,0x00000062,0x00000063,0x00000003,0x00090019,0x00000065,0x00000006,
+	0x00000001,0x00000000,0x00000000,0x00000000,0x00000001,0x00000000,0x0003001b,0x00000066,
+	0x00000065,0x00040020,0x00000067,0x00000000,0x00000066,0x0004003b,0x00000067,0x00000068,
+	0x00000000,0x00040020,0x0000006a,0x00000001,0x00000012,0x0004003b,0x0000006a,0x0000006b,
+	0x00000001,0x00040017,0x0000006c,0x00000006,0x00000002,0x00050036,0x00000002,0x00000004,
+	0x00000000,0x00000003,0x000200f8,0x00000005,0x0004003b,0x0000000d,0x0000004c,0x00000007,
+	0x0004003b,0x0000000d,0x00000051,0x00000007,0x0004003b,0x0000000d,0x00000054,0x00000007,
+	0x0004003b,0x00000007,0x00000059,0x00000007,0x0004003b,0x00000013,0x00000071,0x00000007,
+	0x0004003d,0x0000000c,0x0000004f,0x0000004e,0x000400cf,0x0000000c,0x00000050,0x0000004f,
+	0x0003003e,0x0000004c,0x00000050,0x0004003d,0x0000000c,0x00000052,0x0000004e,0x000400d0,
+	0x0000000c,0x00000053,0x00000052,0x0003003e,0x00000051,0x00000053,0x0004003d,0x0000000c,
+	0x00000055,0x0000004c,0x0004003d,0x0000000c,0x00000056,0x00000051,0x0007000c,0x0000000c,
+	0x00000057,0x00000001,0x00000044,0x00000055,0x00000056,0x0006000c,0x0000000c,0x00000058,
+	0x00000001,0x00000045,0x00000057,0x0003003e,0x00000054,0x00000058,0x0004003d,0x0000000c,
+	0x0000005f,0x00000054,0x00050094,0x00000006,0x00000060,0x0000005e,0x0000005f,0x0007000c,
+	0x00000006,0x00000061,0x00000001,0x00000028,0x0000005a,0x00000060,0x0003003e,0x00000059,
+	0x00000061,0x0004003d,0x00000006,0x00000064,0x00000059,0x0004003d,0x00000066,0x00000069,
+	0x00000068,0x0004003d,0x00000012,0x0000006d,0x0000006b,0x0007004f,0x0000006c,0x0000006e,
+	0x0000006d,0x0000006d,0x00000000,0x00000001,0x00050057,0x00000012,0x0000006f,0x00000069,
+	0x0000006e,0x0005008e,0x00000012,0x00000070,0x0000006f,0x00000064,0x0003003e,0x00000071,
+	0x00000070,0x00050039,0x00000012,0x00000072,0x00000016,0x00000071,0x0003003e,0x00000063,
+	0x00000072,0x000100fd,0x00010038,0x00050036,0x00000006,0x0000000a,0x00000000,0x00000008,
+	0x00030037,0x00000007,0x00000009,0x000200f8,0x0000000b,0x0004003d,0x00000006,0x00000018,
+	0x00000009,0x000500bc,0x0000001a,0x0000001b,0x00000018,0x00000019,0x000300f7,0x0000001d,
+	0x00000000,0x000400fa,0x0000001b,0x0000001c,0x00000022,0x000200f8,0x0000001c,0x0004003d,
+	0x00000006,0x0000001e,0x00000009,0x00050085,0x00000006,0x00000020,0x0000001e,0x0000001f,
+	0x000200fe,0x00000020,0x000200f8,0x00000022,0x0004003d,0x00000006,0x00000024,0x00000009,
+	0x0007000c,0x00000006,0x00000026,0x00000001,0x0000001a,0x00000024,0x00000025,0x00050085,
+	0x00000006,0x00000027,0x00000023,0x00000026,0x00050083,0x00000006,0x00000029,0x00000027,
+	0x00000028,0x000200fe,0x00000029,0x000200f8,0x0000001d,0x000100ff,0x00010038,0x00050036,
+	0x0000000c,0x00000010,0x00000000,0x0000000e,0x00030037,0x0000000d,0x0000000f,0x000200f8,
+	0x00000011,0x0004003b,0x00000007,0x0000002c,0x00000007,0x0004003b,0x00000007,0x00000032,
+	0x00000007,0x0004003b,0x00000007,0x00000037,0x00000007,0x00050041,0x00000007,0x0000002f,
+	0x0000000f,0x0000002e,0x0004003d,0x00000006,0x00000030,0x0000002f,0x0003003e,0x0000002c,
+	0x00000030,0x00050039,0x00000006,0x00000031,0x0000000a,0x0000002c,0x00050041,0x00000007,
+	0x00000034,0x0000000f,0x00000033,0x0004003d,0x00000006,0x00000035,0x00000034,0x0003003e,
+	0x00000032,0x00000035,0x00050039,0x00000006,0x00000036,0x0000000a,0x00000032,0x00050041,
+	0x00000007,0x00000039,0x0000000f,0x00000038,0x0004003d,0x00000006,0x0000003a,0x00000039,
+	0x0003003e,0x00000037,0x0000003a,0x00050039,0x00000006,0x0000003b,0x0000000a,0x00000037,
+	0x00060050,0x0000000c,0x0000003c,0x00000031,0x00000036,0x0000003b,0x000200fe,0x0000003c,
+	0x00010038,0x00050036,0x00000012,0x00000016,0x00000000,0x00000014,0x00030037,0x00000013,
+	0x00000015,0x000200f8,0x00000017,0x0004003b,0x0000000d,0x0000003f,0x00000007,0x0004003d,
+	0x00000012,0x00000040,0x00000015,0x0008004f,0x0000000c,0x00000041,0x00000040,0x00000040,
+	0x00000000,0x00000001,0x00000002,0x0003003e,0x0000003f,0x00000041,0x00050039,0x0000000c,
+	0x00000042,0x00000010,0x0000003f,0x00050041,0x00000007,0x00000044,0x00000015,0x00000043,
+	0x0004003d,0x00000006,0x00000045,0x00000044,0x00050051,0x00000006,0x00000046,0x00000042,
+	0x00000000,0x00050051,0x00000006,0x00000047,0x00000042,0x00000001,0x00050051,0x00000006,
+	0x00000048,0x00000042,0x00000002,0x00070050,0x00000012,0x00000049,0x00000046,0x00000047,
+	0x00000048,0x00000045,0x000200fe,0x00000049,0x00010038
diff --git a/tools/Vulkan-Tools/cube/cube.vert b/tools/Vulkan-Tools/cube/cube.vert
new file mode 100644
index 00000000..63380326
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/cube.vert
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2015-2016 The Khronos Group Inc.
+ * Copyright (c) 2015-2016 Valve Corporation
+ * Copyright (c) 2015-2016 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*
+ * Vertex shader used by Cube demo.
+ */
+#version 400
+#extension GL_ARB_separate_shader_objects : enable
+#extension GL_ARB_shading_language_420pack : enable
+layout(std140, binding = 0) uniform buf {
+        mat4 MVP;
+        vec4 position[12*3];
+        vec4 attr[12*3];
+} ubuf;
+
+layout (location = 0) out vec4 texcoord;
+layout (location = 1) out vec3 frag_pos;
+
+void main() 
+{
+   texcoord = ubuf.attr[gl_VertexIndex];
+   gl_Position = ubuf.MVP * ubuf.position[gl_VertexIndex];
+   frag_pos = gl_Position.xyz;
+}
diff --git a/tools/Vulkan-Tools/cube/cube.vert.inc b/tools/Vulkan-Tools/cube/cube.vert.inc
new file mode 100644
index 00000000..f5c3fef0
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/cube.vert.inc
@@ -0,0 +1,50 @@
+	// 1115.1.0
+	0x07230203,0x00010000,0x0008000b,0x0000002f,0x00000000,0x00020011,0x00000001,0x0006000b,
+	0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001,
+	0x0009000f,0x00000000,0x00000004,0x6e69616d,0x00000000,0x00000009,0x00000015,0x0000001e,
+	0x0000002b,0x00030003,0x00000002,0x00000190,0x00090004,0x415f4c47,0x735f4252,0x72617065,
+	0x5f657461,0x64616873,0x6f5f7265,0x63656a62,0x00007374,0x00090004,0x415f4c47,0x735f4252,
+	0x69646168,0x6c5f676e,0x75676e61,0x5f656761,0x70303234,0x006b6361,0x00040005,0x00000004,
+	0x6e69616d,0x00000000,0x00050005,0x00000009,0x63786574,0x64726f6f,0x00000000,0x00030005,
+	0x0000000f,0x00667562,0x00040006,0x0000000f,0x00000000,0x0050564d,0x00060006,0x0000000f,
+	0x00000001,0x69736f70,0x6e6f6974,0x00000000,0x00050006,0x0000000f,0x00000002,0x72747461,
+	0x00000000,0x00040005,0x00000011,0x66756275,0x00000000,0x00060005,0x00000015,0x565f6c67,
+	0x65747265,0x646e4978,0x00007865,0x00060005,0x0000001c,0x505f6c67,0x65567265,0x78657472,
+	0x00000000,0x00060006,0x0000001c,0x00000000,0x505f6c67,0x7469736f,0x006e6f69,0x00070006,
+	0x0000001c,0x00000001,0x505f6c67,0x746e696f,0x657a6953,0x00000000,0x00070006,0x0000001c,
+	0x00000002,0x435f6c67,0x4470696c,0x61747369,0x0065636e,0x00030005,0x0000001e,0x00000000,
+	0x00050005,0x0000002b,0x67617266,0x736f705f,0x00000000,0x00040047,0x00000009,0x0000001e,
+	0x00000000,0x00040047,0x0000000d,0x00000006,0x00000010,0x00040047,0x0000000e,0x00000006,
+	0x00000010,0x00030047,0x0000000f,0x00000002,0x00040048,0x0000000f,0x00000000,0x00000005,
+	0x00050048,0x0000000f,0x00000000,0x00000007,0x00000010,0x00050048,0x0000000f,0x00000000,
+	0x00000023,0x00000000,0x00050048,0x0000000f,0x00000001,0x00000023,0x00000040,0x00050048,
+	0x0000000f,0x00000002,0x00000023,0x00000280,0x00040047,0x00000011,0x00000021,0x00000000,
+	0x00040047,0x00000011,0x00000022,0x00000000,0x00040047,0x00000015,0x0000000b,0x0000002a,
+	0x00030047,0x0000001c,0x00000002,0x00050048,0x0000001c,0x00000000,0x0000000b,0x00000000,
+	0x00050048,0x0000001c,0x00000001,0x0000000b,0x00000001,0x00050048,0x0000001c,0x00000002,
+	0x0000000b,0x00000003,0x00040047,0x0000002b,0x0000001e,0x00000001,0x00020013,0x00000002,
+	0x00030021,0x00000003,0x00000002,0x00030016,0x00000006,0x00000020,0x00040017,0x00000007,
+	0x00000006,0x00000004,0x00040020,0x00000008,0x00000003,0x00000007,0x0004003b,0x00000008,
+	0x00000009,0x00000003,0x00040018,0x0000000a,0x00000007,0x00000004,0x00040015,0x0000000b,
+	0x00000020,0x00000000,0x0004002b,0x0000000b,0x0000000c,0x00000024,0x0004001c,0x0000000d,
+	0x00000007,0x0000000c,0x0004001c,0x0000000e,0x00000007,0x0000000c,0x0005001e,0x0000000f,
+	0x0000000a,0x0000000d,0x0000000e,0x00040020,0x00000010,0x00000002,0x0000000f,0x0004003b,
+	0x00000010,0x00000011,0x00000002,0x00040015,0x00000012,0x00000020,0x00000001,0x0004002b,
+	0x00000012,0x00000013,0x00000002,0x00040020,0x00000014,0x00000001,0x00000012,0x0004003b,
+	0x00000014,0x00000015,0x00000001,0x00040020,0x00000017,0x00000002,0x00000007,0x0004002b,
+	0x0000000b,0x0000001a,0x00000001,0x0004001c,0x0000001b,0x00000006,0x0000001a,0x0005001e,
+	0x0000001c,0x00000007,0x00000006,0x0000001b,0x00040020,0x0000001d,0x00000003,0x0000001c,
+	0x0004003b,0x0000001d,0x0000001e,0x00000003,0x0004002b,0x00000012,0x0000001f,0x00000000,
+	0x00040020,0x00000020,0x00000002,0x0000000a,0x0004002b,0x00000012,0x00000023,0x00000001,
+	0x00040017,0x00000029,0x00000006,0x00000003,0x00040020,0x0000002a,0x00000003,0x00000029,
+	0x0004003b,0x0000002a,0x0000002b,0x00000003,0x00050036,0x00000002,0x00000004,0x00000000,
+	0x00000003,0x000200f8,0x00000005,0x0004003d,0x00000012,0x00000016,0x00000015,0x00060041,
+	0x00000017,0x00000018,0x00000011,0x00000013,0x00000016,0x0004003d,0x00000007,0x00000019,
+	0x00000018,0x0003003e,0x00000009,0x00000019,0x00050041,0x00000020,0x00000021,0x00000011,
+	0x0000001f,0x0004003d,0x0000000a,0x00000022,0x00000021,0x0004003d,0x00000012,0x00000024,
+	0x00000015,0x00060041,0x00000017,0x00000025,0x00000011,0x00000023,0x00000024,0x0004003d,
+	0x00000007,0x00000026,0x00000025,0x00050091,0x00000007,0x00000027,0x00000022,0x00000026,
+	0x00050041,0x00000008,0x00000028,0x0000001e,0x0000001f,0x0003003e,0x00000028,0x00000027,
+	0x00050041,0x00000008,0x0000002c,0x0000001e,0x0000001f,0x0004003d,0x00000007,0x0000002d,
+	0x0000002c,0x0008004f,0x00000029,0x0000002e,0x0000002d,0x0000002d,0x00000000,0x00000001,
+	0x00000002,0x0003003e,0x0000002b,0x0000002e,0x000100fd,0x00010038
diff --git a/tools/Vulkan-Tools/cube/cube_functions.h b/tools/Vulkan-Tools/cube/cube_functions.h
new file mode 100644
index 00000000..975f65f6
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/cube_functions.h
@@ -0,0 +1,355 @@
+/*
+ * Copyright (c) 2025 The Khronos Group Inc.
+ * Copyright (c) 2025 Valve Corporation
+ * Copyright (c) 2025 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Charles Giessen <charles@lunarg.com>
+ *
+ */
+#pragma once
+
+// Need to include relevant system headers to open the dynamic library
+#if defined(_WIN32)
+#include <windows.h>
+#elif defined(__APPLE__)
+#include <stdlib.h>
+#include <dlfcn.h>
+#else
+#include <dlfcn.h>
+#endif
+
+// We are providing storage for all functions, make sure the vulkan headers doesn't conflate with ours.
+#if !defined(VK_NO_PROTOTYPES)
+#define VK_NO_PROTOTYPES
+#endif
+
+#include <vulkan/vulkan.h>
+
+void* vulkan_library;
+
+// Global Functions
+PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
+PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties;
+PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties;
+PFN_vkCreateInstance vkCreateInstance;
+
+// Per-platform Instance functions
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR;
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR;
+#endif
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR;
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR;
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR;
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT;
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT;
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX;
+#endif
+
+// Instance functions
+PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT;
+PFN_vkCreateDevice vkCreateDevice;
+PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT;
+PFN_vkDestroyInstance vkDestroyInstance;
+PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR;
+PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties;
+PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices;
+PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR;
+PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR;
+PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR;
+PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR;
+PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR;
+PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures;
+PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties;
+PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
+PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties;
+PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties;
+PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
+PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR;
+PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR;
+PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR;
+PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR;
+
+// While technically a device function, it needs to be loaded with get instance proc addr
+PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr;
+
+// Device functions
+PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR;
+PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers;
+PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets;
+PFN_vkAllocateMemory vkAllocateMemory;
+PFN_vkBeginCommandBuffer vkBeginCommandBuffer;
+PFN_vkBindBufferMemory vkBindBufferMemory;
+PFN_vkBindImageMemory vkBindImageMemory;
+PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT;
+PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass;
+PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets;
+PFN_vkCmdBindPipeline vkCmdBindPipeline;
+PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage;
+PFN_vkCmdDraw vkCmdDraw;
+PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT;
+PFN_vkCmdEndRenderPass vkCmdEndRenderPass;
+PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier;
+PFN_vkCmdSetScissor vkCmdSetScissor;
+PFN_vkCmdSetViewport vkCmdSetViewport;
+PFN_vkCreateBuffer vkCreateBuffer;
+PFN_vkCreateCommandPool vkCreateCommandPool;
+PFN_vkCreateDescriptorPool vkCreateDescriptorPool;
+PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout;
+PFN_vkCreateFence vkCreateFence;
+PFN_vkCreateFramebuffer vkCreateFramebuffer;
+PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines;
+PFN_vkCreateImage vkCreateImage;
+PFN_vkCreateImageView vkCreateImageView;
+PFN_vkCreatePipelineCache vkCreatePipelineCache;
+PFN_vkCreatePipelineLayout vkCreatePipelineLayout;
+PFN_vkCreateRenderPass vkCreateRenderPass;
+PFN_vkCreateSampler vkCreateSampler;
+PFN_vkCreateSemaphore vkCreateSemaphore;
+PFN_vkCreateShaderModule vkCreateShaderModule;
+PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR;
+PFN_vkDestroyBuffer vkDestroyBuffer;
+PFN_vkDestroyCommandPool vkDestroyCommandPool;
+PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool;
+PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout;
+PFN_vkDestroyDevice vkDestroyDevice;
+PFN_vkDestroyFence vkDestroyFence;
+PFN_vkDestroyFramebuffer vkDestroyFramebuffer;
+PFN_vkDestroyImage vkDestroyImage;
+PFN_vkDestroyImageView vkDestroyImageView;
+PFN_vkDestroyPipeline vkDestroyPipeline;
+PFN_vkDestroyPipelineCache vkDestroyPipelineCache;
+PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout;
+PFN_vkDestroyRenderPass vkDestroyRenderPass;
+PFN_vkDestroySampler vkDestroySampler;
+PFN_vkDestroySemaphore vkDestroySemaphore;
+PFN_vkDestroyShaderModule vkDestroyShaderModule;
+PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR;
+PFN_vkDeviceWaitIdle vkDeviceWaitIdle;
+PFN_vkEndCommandBuffer vkEndCommandBuffer;
+PFN_vkFreeCommandBuffers vkFreeCommandBuffers;
+PFN_vkFreeMemory vkFreeMemory;
+PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements;
+PFN_vkGetDeviceQueue vkGetDeviceQueue;
+PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
+PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout;
+PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE;
+PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE;
+PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR;
+PFN_vkMapMemory vkMapMemory;
+PFN_vkQueuePresentKHR vkQueuePresentKHR;
+PFN_vkQueueSubmit vkQueueSubmit;
+PFN_vkResetCommandBuffer vkResetCommandBuffer;
+PFN_vkResetFences vkResetFences;
+PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT;
+PFN_vkUnmapMemory vkUnmapMemory;
+PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets;
+PFN_vkWaitForFences vkWaitForFences;
+
+#define LOAD_INSTANCE_FUNCTION(instance, function) function = (PFN_##function)vkGetInstanceProcAddr(instance, #function)
+#define LOAD_DEVICE_FUNCTION(device, function) function = (PFN_##function)vkGetDeviceProcAddr(device, #function)
+
+static VkResult load_vulkan_library() {
+    vulkan_library = NULL;
+#if defined(WIN32)
+    HMODULE library = LoadLibraryA("vulkan-1.dll");
+    if (library == NULL) return VK_ERROR_INITIALIZATION_FAILED;
+
+    vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)(void (*)(void))GetProcAddress(library, "vkGetInstanceProcAddr");
+#elif defined(__APPLE__)
+    void* library = dlopen("libvulkan.dylib", RTLD_NOW | RTLD_LOCAL);
+    if (library == NULL) {
+        library = dlopen("libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL);
+    }
+    if (library == NULL && getenv("DYLD_FALLBACK_LIBRARY_PATH") == NULL) {
+        library = dlopen("/usr/local/lib/libvulkan.dylib", RTLD_NOW | RTLD_LOCAL);
+        if (library == NULL) {
+            library = dlopen("/usr/local/lib/libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL);
+        }
+    }
+    if (library == NULL) {
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+
+    vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)dlsym(library, "vkGetInstanceProcAddr");
+#else  // Assume everything else supports dlopen
+    void* library = dlopen("libvulkan.so.1", RTLD_NOW | RTLD_LOCAL);
+    if (library == NULL) library = dlopen("libvulkan.so", RTLD_NOW | RTLD_LOCAL);
+    if (library == NULL) {
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+    vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)dlsym(library, "vkGetInstanceProcAddr");
+#endif
+    if (vkGetInstanceProcAddr == NULL) {
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+    vulkan_library = library;
+    LOAD_INSTANCE_FUNCTION(NULL, vkEnumerateInstanceExtensionProperties);
+    LOAD_INSTANCE_FUNCTION(NULL, vkEnumerateInstanceLayerProperties);
+    LOAD_INSTANCE_FUNCTION(NULL, vkCreateInstance);
+
+    return VK_SUCCESS;
+}
+
+static void unload_vulkan_library() {
+    if (vulkan_library != NULL) {
+#if defined(WIN32)
+        FreeLibrary((HMODULE)vulkan_library);
+#else
+        dlclose(vulkan_library);
+#endif
+        vulkan_library = NULL;
+    }
+}
+
+static void load_vulkan_instance_functions(VkInstance instance) {
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateWin32SurfaceKHR);
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateWaylandSurfaceKHR);
+#endif
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateAndroidSurfaceKHR);
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateXlibSurfaceKHR);
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateXcbSurfaceKHR);
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateMetalSurfaceEXT);
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateDirectFBSurfaceEXT);
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateScreenSurfaceQNX);
+#endif
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateDebugUtilsMessengerEXT);
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateDevice);
+    LOAD_INSTANCE_FUNCTION(instance, vkDestroyDebugUtilsMessengerEXT);
+    LOAD_INSTANCE_FUNCTION(instance, vkDestroyInstance);
+    LOAD_INSTANCE_FUNCTION(instance, vkDestroySurfaceKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkEnumerateDeviceExtensionProperties);
+    LOAD_INSTANCE_FUNCTION(instance, vkEnumeratePhysicalDevices);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetDisplayModePropertiesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetDisplayPlaneCapabilitiesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetDisplayPlaneSupportedDisplaysKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceDisplayPlanePropertiesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceDisplayPropertiesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceFeatures);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceFormatProperties);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceMemoryProperties);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceProperties);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceQueueFamilyProperties);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfaceCapabilitiesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfaceFormatsKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfacePresentModesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfaceSupportKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetDeviceProcAddr);
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateDisplayPlaneSurfaceKHR);
+}
+static void load_vulkan_device_functions(VkDevice device) {
+    LOAD_DEVICE_FUNCTION(device, vkAcquireNextImageKHR);
+    LOAD_DEVICE_FUNCTION(device, vkAllocateCommandBuffers);
+    LOAD_DEVICE_FUNCTION(device, vkAllocateDescriptorSets);
+    LOAD_DEVICE_FUNCTION(device, vkAllocateMemory);
+    LOAD_DEVICE_FUNCTION(device, vkBeginCommandBuffer);
+    LOAD_DEVICE_FUNCTION(device, vkBindBufferMemory);
+    LOAD_DEVICE_FUNCTION(device, vkBindImageMemory);
+    LOAD_DEVICE_FUNCTION(device, vkCmdBeginDebugUtilsLabelEXT);
+    LOAD_DEVICE_FUNCTION(device, vkCmdBeginRenderPass);
+    LOAD_DEVICE_FUNCTION(device, vkCmdBindDescriptorSets);
+    LOAD_DEVICE_FUNCTION(device, vkCmdBindPipeline);
+    LOAD_DEVICE_FUNCTION(device, vkCmdCopyBufferToImage);
+    LOAD_DEVICE_FUNCTION(device, vkCmdDraw);
+    LOAD_DEVICE_FUNCTION(device, vkCmdEndDebugUtilsLabelEXT);
+    LOAD_DEVICE_FUNCTION(device, vkCmdEndRenderPass);
+    LOAD_DEVICE_FUNCTION(device, vkCmdPipelineBarrier);
+    LOAD_DEVICE_FUNCTION(device, vkCmdSetScissor);
+    LOAD_DEVICE_FUNCTION(device, vkCmdSetViewport);
+    LOAD_DEVICE_FUNCTION(device, vkCreateBuffer);
+    LOAD_DEVICE_FUNCTION(device, vkCreateCommandPool);
+    LOAD_DEVICE_FUNCTION(device, vkCreateDescriptorPool);
+    LOAD_DEVICE_FUNCTION(device, vkCreateDescriptorSetLayout);
+    LOAD_DEVICE_FUNCTION(device, vkCreateFence);
+    LOAD_DEVICE_FUNCTION(device, vkCreateFramebuffer);
+    LOAD_DEVICE_FUNCTION(device, vkCreateGraphicsPipelines);
+    LOAD_DEVICE_FUNCTION(device, vkCreateImage);
+    LOAD_DEVICE_FUNCTION(device, vkCreateImageView);
+    LOAD_DEVICE_FUNCTION(device, vkCreatePipelineCache);
+    LOAD_DEVICE_FUNCTION(device, vkCreatePipelineLayout);
+    LOAD_DEVICE_FUNCTION(device, vkCreateRenderPass);
+    LOAD_DEVICE_FUNCTION(device, vkCreateSampler);
+    LOAD_DEVICE_FUNCTION(device, vkCreateSemaphore);
+    LOAD_DEVICE_FUNCTION(device, vkCreateShaderModule);
+    LOAD_DEVICE_FUNCTION(device, vkCreateSwapchainKHR);
+    LOAD_DEVICE_FUNCTION(device, vkDestroyBuffer);
+    LOAD_DEVICE_FUNCTION(device, vkDestroyCommandPool);
+    LOAD_DEVICE_FUNCTION(device, vkDestroyDescriptorPool);
+    LOAD_DEVICE_FUNCTION(device, vkDestroyDescriptorSetLayout);
+    LOAD_DEVICE_FUNCTION(device, vkDestroyDevice);
+    LOAD_DEVICE_FUNCTION(device, vkDestroyFence);
+    LOAD_DEVICE_FUNCTION(device, vkDestroyFramebuffer);
+    LOAD_DEVICE_FUNCTION(device, vkDestroyImage);
+    LOAD_DEVICE_FUNCTION(device, vkDestroyImageView);
+    LOAD_DEVICE_FUNCTION(device, vkDestroyPipeline);
+    LOAD_DEVICE_FUNCTION(device, vkDestroyPipelineCache);
+    LOAD_DEVICE_FUNCTION(device, vkDestroyPipelineLayout);
+    LOAD_DEVICE_FUNCTION(device, vkDestroyRenderPass);
+    LOAD_DEVICE_FUNCTION(device, vkDestroySampler);
+    LOAD_DEVICE_FUNCTION(device, vkDestroySemaphore);
+    LOAD_DEVICE_FUNCTION(device, vkDestroyShaderModule);
+    LOAD_DEVICE_FUNCTION(device, vkDestroySwapchainKHR);
+    LOAD_DEVICE_FUNCTION(device, vkDeviceWaitIdle);
+    LOAD_DEVICE_FUNCTION(device, vkEndCommandBuffer);
+    LOAD_DEVICE_FUNCTION(device, vkFreeCommandBuffers);
+    LOAD_DEVICE_FUNCTION(device, vkFreeMemory);
+    LOAD_DEVICE_FUNCTION(device, vkGetBufferMemoryRequirements);
+    LOAD_DEVICE_FUNCTION(device, vkGetDeviceProcAddr);
+    LOAD_DEVICE_FUNCTION(device, vkGetDeviceQueue);
+    LOAD_DEVICE_FUNCTION(device, vkGetImageMemoryRequirements);
+    LOAD_DEVICE_FUNCTION(device, vkGetImageSubresourceLayout);
+    LOAD_DEVICE_FUNCTION(device, vkGetPastPresentationTimingGOOGLE);
+    LOAD_DEVICE_FUNCTION(device, vkGetRefreshCycleDurationGOOGLE);
+    LOAD_DEVICE_FUNCTION(device, vkGetSwapchainImagesKHR);
+    LOAD_DEVICE_FUNCTION(device, vkMapMemory);
+    LOAD_DEVICE_FUNCTION(device, vkQueuePresentKHR);
+    LOAD_DEVICE_FUNCTION(device, vkQueueSubmit);
+    LOAD_DEVICE_FUNCTION(device, vkResetCommandBuffer);
+    LOAD_DEVICE_FUNCTION(device, vkResetFences);
+    LOAD_DEVICE_FUNCTION(device, vkSetDebugUtilsObjectNameEXT);
+    LOAD_DEVICE_FUNCTION(device, vkUnmapMemory);
+    LOAD_DEVICE_FUNCTION(device, vkUpdateDescriptorSets);
+    LOAD_DEVICE_FUNCTION(device, vkWaitForFences);
+}
+
+#undef LOAD_INSTANCE_FUNCTION
+#undef LOAD_DEVICE_FUNCTION
diff --git a/tools/Vulkan-Tools/cube/fuchsia/flatland_view.cpp b/tools/Vulkan-Tools/cube/fuchsia/flatland_view.cpp
new file mode 100644
index 00000000..029c07d3
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/fuchsia/flatland_view.cpp
@@ -0,0 +1,210 @@
+// Copyright (c) 2025 The Fuchsia Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "flatland_view.h"
+
+#include <fidl/fuchsia.ui.app/cpp/fidl.h>
+#include <fidl/fuchsia.ui.composition/cpp/fidl.h>
+#include <fidl/fuchsia.ui.views/cpp/fidl.h>
+#include <lib/component/incoming/cpp/protocol.h>
+#include <lib/component/outgoing/cpp/outgoing_directory.h>
+#include <lib/syslog/cpp/macros.h>
+#include <lib/syslog/global.h>
+#include <lib/ui/scenic/cpp/view_creation_tokens.h>
+#include <lib/ui/scenic/cpp/view_identity.h>
+
+#include <cinttypes>
+
+namespace {
+
+const char* const kTag = "FlatlandView";
+
+const fuchsia_ui_composition::TransformId kRootTransform = {1};
+const fuchsia_ui_composition::ContentId kViewport = {1};
+
+}  // namespace
+
+// static
+std::unique_ptr<FlatlandView> FlatlandView::Create(fidl::UnownedClientEnd<fuchsia_io::Directory> service_directory,
+                                                   fuchsia_ui_views::ViewCreationToken view_creation_token,
+                                                   ResizeCallback resize_callback, async_dispatcher_t* dispatcher) {
+    ZX_DEBUG_ASSERT(dispatcher != nullptr);
+    auto view = std::make_unique<FlatlandView>(std::move(resize_callback), dispatcher);
+    if (!view) return nullptr;
+    if (!view->Init(service_directory, std::move(view_creation_token))) return nullptr;
+    return view;
+}
+
+FlatlandView::FlatlandView(ResizeCallback resize_callback, async_dispatcher_t* dispatcher)
+    : resize_callback_(std::move(resize_callback)), dispatcher_(dispatcher) {
+    ZX_DEBUG_ASSERT(dispatcher != nullptr);
+}
+
+bool FlatlandView::Init(fidl::UnownedClientEnd<fuchsia_io::Directory> service_directory,
+                        fuchsia_ui_views::ViewCreationToken view_creation_token) {
+    zx::result<fidl::ClientEnd<fuchsia_ui_composition::Flatland>> connect_result =
+        component::ConnectAt<fuchsia_ui_composition::Flatland>(service_directory);
+    if (connect_result.is_error()) {
+        FX_LOGS(ERROR) << "Failed to connect to Flatland: " << connect_result.status_string();
+        return false;
+    }
+    fidl::ClientEnd<fuchsia_ui_composition::Flatland> flatland_client = std::move(connect_result).value();
+    flatland_.Bind(std::move(flatland_client), dispatcher_, /*event_handler=*/this);
+    fit::result<fidl::OneWayError> set_debug_name_result = flatland_->SetDebugName({{.name = kTag}});
+    if (set_debug_name_result.is_error()) {
+        FX_LOGS(ERROR) << "Failed to set debug name: " << set_debug_name_result.error_value().FormatDescription();
+    }
+
+    fit::result<fidl::OneWayError> create_transform_result = flatland_->CreateTransform(kRootTransform);
+    if (create_transform_result.is_error()) {
+        FX_LOGS(ERROR) << "Failed to call CreateTransform: " << create_transform_result.error_value().FormatDescription();
+        return false;
+    }
+
+    fit::result<fidl::OneWayError> set_root_transform_result = flatland_->SetRootTransform(kRootTransform);
+    if (set_root_transform_result.is_error()) {
+        FX_LOGS(ERROR) << "Failed to call SetRootTransform: " << set_root_transform_result.error_value().FormatDescription();
+        return false;
+    }
+
+    auto [parent_viewport_watcher_client, parent_viewport_watcher_server] =
+        fidl::Endpoints<fuchsia_ui_composition::ParentViewportWatcher>::Create();
+    fit::result<fidl::OneWayError> create_view2_result = flatland_->CreateView2({{
+        .token = std::move(view_creation_token),
+        .view_identity = scenic::cpp::NewViewIdentityOnCreation(),
+        .protocols = {},
+        .parent_viewport_watcher = std::move(parent_viewport_watcher_server),
+    }});
+    if (create_view2_result.is_error()) {
+        FX_LOGS(ERROR) << "Failed to call CreateView2: " << set_root_transform_result.error_value().FormatDescription();
+        return false;
+    }
+
+    parent_viewport_watcher_.Bind(std::move(parent_viewport_watcher_client), dispatcher_);
+    parent_viewport_watcher_->GetLayout().Then(
+        [this](fidl::Result<fuchsia_ui_composition::ParentViewportWatcher::GetLayout>& result) {
+            if (result.is_error()) {
+                FX_LOGS(ERROR) << "GetLayout() failed: " << result.error_value().FormatDescription();
+                return;
+            }
+            OnGetLayout(std::move(result.value().info()));
+        });
+
+    zx::channel::create(0, &viewport_creation_token_.value(), &child_view_creation_token_.value());
+
+    return true;
+}
+
+void FlatlandView::OnGetLayout(fuchsia_ui_composition::LayoutInfo info) {
+    ZX_DEBUG_ASSERT(info.logical_size().has_value());
+    const fuchsia_math::SizeU& logical_size = info.logical_size().value();
+    resize_callback_(logical_size.width(), logical_size.height());
+
+    fuchsia_ui_composition::ViewportProperties properties = {{.logical_size = logical_size}};
+    if (viewport_creation_token_.value().is_valid()) {
+        // The first time that we receive layout information, create a viewport using the token that was stashed during Init().
+        // External code will attach a view to this viewport via the token obtained from TakeChildViewCreationToken().
+        auto [child_view_watcher_client, child_view_watcher_server] =
+            fidl::Endpoints<fuchsia_ui_composition::ChildViewWatcher>::Create();
+        fit::result<fidl::OneWayError> create_viewport_result = flatland_->CreateViewport({{
+            .viewport_id = kViewport,
+            .token = std::move(viewport_creation_token_),
+            .properties = std::move(properties),
+            .child_view_watcher = std::move(child_view_watcher_server),
+        }});
+        if (create_viewport_result.is_error()) {
+            FX_LOGS(ERROR) << "Failed to call CreateViewport(): " << create_viewport_result.error_value().FormatDescription();
+            return;
+        }
+
+        fit::result<fidl::OneWayError> set_content_result = flatland_->SetContent({{
+            .transform_id = kRootTransform,
+            .content_id = kViewport,
+        }});
+        if (set_content_result.is_error()) {
+            FX_LOGS(ERROR) << "Failed to call SetContent(): " << set_content_result.error_value().FormatDescription();
+            return;
+        }
+    } else {
+        auto set_viewport_properties_result = flatland_->SetViewportProperties({{
+            .viewport_id = kViewport,
+            .properties = std::move(properties),
+        }});
+        if (set_viewport_properties_result.is_error()) {
+            FX_LOGS(ERROR) << "Failed to call SetViewportProperties(): "
+                           << set_viewport_properties_result.error_value().FormatDescription();
+            return;
+        }
+    }
+
+    Present();
+    parent_viewport_watcher_->GetLayout().Then(
+        [this](fidl::Result<fuchsia_ui_composition::ParentViewportWatcher::GetLayout>& result) {
+            if (result.is_error()) {
+                FX_LOGS(ERROR) << "GetLayout() failed: " << result.error_value().FormatDescription();
+                return;
+            }
+            OnGetLayout(std::move(result.value().info()));
+        });
+}
+
+void FlatlandView::OnError(fidl::Event<fuchsia_ui_composition::Flatland::OnError>& event) {
+    FX_LOGF(ERROR, kTag, "OnFlatlandError: %" PRIu32, static_cast<uint32_t>(event.error()));
+}
+
+void FlatlandView::Present() {
+    if (present_credits_ == 0) {
+        pending_present_ = true;
+        return;
+    }
+    --present_credits_;
+    fuchsia_ui_composition::PresentArgs present_args = {{
+        .requested_presentation_time = 0,
+        .acquire_fences = {},
+        .release_fences = {},
+        .unsquashable = false,
+    }};
+    fit::result<fidl::OneWayError> present_result = flatland_->Present(std::move(present_args));
+    if (present_result.is_error()) {
+        FX_LOGS(ERROR) << "Failed to call Present(): " << present_result.error_value().FormatDescription();
+    }
+}
+
+void FlatlandView::OnFramePresented(fidl::Event<fuchsia_ui_composition::Flatland::OnFramePresented>& event) {}
+
+void FlatlandView::OnNextFrameBegin(fidl::Event<fuchsia_ui_composition::Flatland::OnNextFrameBegin>& event) {
+    present_credits_ += event.values().additional_present_credits().value_or(0);
+    if (present_credits_ > 0 && pending_present_) {
+        Present();
+        pending_present_ = false;
+    }
+}
+
+FlatlandViewProviderService::FlatlandViewProviderService(CreateView2Callback create_view_callback, async_dispatcher_t* dispatcher)
+    : create_view_callback_(std::move(create_view_callback)), dispatcher_(dispatcher) {
+    ZX_DEBUG_ASSERT(dispatcher != nullptr);
+}
+
+void FlatlandViewProviderService::CreateViewWithViewRef(CreateViewWithViewRefRequest& request,
+                                                        CreateViewWithViewRefCompleter::Sync& completer) {
+    FX_NOTIMPLEMENTED() << "Only Flatland is supported. This is a Gfx ViewProvider method.";
+}
+
+void FlatlandViewProviderService::CreateView2(CreateView2Request& request, CreateView2Completer::Sync& completer) {
+    create_view_callback_(std::move(request.args()));
+}
+
+void FlatlandViewProviderService::HandleViewProviderRequest(fidl::ServerEnd<fuchsia_ui_app::ViewProvider> server_end) {
+    bindings_.AddBinding(dispatcher_, std::move(server_end), this, fidl::kIgnoreBindingClosure);
+}
diff --git a/tools/Vulkan-Tools/cube/fuchsia/flatland_view.h b/tools/Vulkan-Tools/cube/fuchsia/flatland_view.h
new file mode 100644
index 00000000..01a8c6f9
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/fuchsia/flatland_view.h
@@ -0,0 +1,102 @@
+// Copyright (c) 2025 The Fuchsia Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef FUCHSIA_FLATLAND_VIEW_H_
+#define FUCHSIA_FLATLAND_VIEW_H_
+
+#include <fidl/fuchsia.io/cpp/fidl.h>
+#include <fidl/fuchsia.ui.app/cpp/fidl.h>
+#include <fidl/fuchsia.ui.composition/cpp/fidl.h>
+#include <fidl/fuchsia.ui.views/cpp/fidl.h>
+#include <lib/fit/function.h>
+#include <lib/async/dispatcher.h>
+#include <lib/syslog/cpp/macros.h>
+
+#include <cstdint>
+#include <utility>
+
+#include <memory>
+
+// This class provides a convenient wrapper around the scenic fidl apis needed to get a Flatland
+// View. Only SDK available constructs should be used so that this code may be leveraged by Vulkan
+// applications built with the SDK.
+class FlatlandView : public fidl::AsyncEventHandler<fuchsia_ui_composition::Flatland> {
+  public:
+    using ResizeCallback = fit::function<void(uint32_t width, uint32_t height)>;
+
+    // Creates and initializes a `FlatlandView` instance.
+    //
+    // `dispatcher` must be non-null.
+    static std::unique_ptr<FlatlandView> Create(fidl::UnownedClientEnd<fuchsia_io::Directory> service_directory,
+                                                fuchsia_ui_views::ViewCreationToken view_creation_token,
+                                                ResizeCallback resize_callback, async_dispatcher_t* dispatcher);
+
+    // Production code must use the `Create()` factory method.
+    //
+    // `dispatcher` must be non-null.
+    explicit FlatlandView(ResizeCallback resize_callback, async_dispatcher_t* dispatcher);
+
+    fuchsia_ui_views::ViewCreationToken TakeChildViewCreationToken() {
+        FX_DCHECK(child_view_creation_token_.value().is_valid());
+        return std::move(child_view_creation_token_);
+    }
+
+    bool Init(fidl::UnownedClientEnd<fuchsia_io::Directory> service_directory,
+              fuchsia_ui_views::ViewCreationToken view_creation_token);
+
+  private:
+    void OnNextFrameBegin(fidl::Event<fuchsia_ui_composition::Flatland::OnNextFrameBegin>& event) override;
+    void OnFramePresented(fidl::Event<fuchsia_ui_composition::Flatland::OnFramePresented>& event) override;
+    void OnError(fidl::Event<fuchsia_ui_composition::Flatland::OnError>& event) override;
+
+    void OnGetLayout(fuchsia_ui_composition::LayoutInfo info);
+    void OnFlatlandError(fuchsia_ui_composition::FlatlandError error);
+    void Present();
+
+    fidl::SharedClient<fuchsia_ui_composition::Flatland> flatland_;
+    fidl::SharedClient<fuchsia_ui_composition::ParentViewportWatcher> parent_viewport_watcher_;
+
+    fuchsia_ui_views::ViewportCreationToken viewport_creation_token_;
+    fuchsia_ui_views::ViewCreationToken child_view_creation_token_;
+    ResizeCallback resize_callback_;
+
+    int64_t present_credits_ = 1;
+    bool pending_present_ = false;
+
+    async_dispatcher_t* const dispatcher_;
+
+    friend class FlatlandViewTest;
+};
+
+class FlatlandViewProviderService : public fidl::Server<fuchsia_ui_app::ViewProvider> {
+  public:
+    using CreateView2Callback = fit::function<void(fuchsia_ui_app::CreateView2Args args)>;
+
+    // `dispatcher` must be non-null.
+    explicit FlatlandViewProviderService(CreateView2Callback create_view_callback, async_dispatcher_t* dispatcher);
+
+    // fuchsia::ui::app::ViewProvider methods.
+    void CreateViewWithViewRef(CreateViewWithViewRefRequest& request, CreateViewWithViewRefCompleter::Sync& completer) override;
+    void CreateView2(CreateView2Request& request, CreateView2Completer::Sync& completer) override;
+
+    void HandleViewProviderRequest(fidl::ServerEnd<fuchsia_ui_app::ViewProvider> server_end);
+
+  private:
+    CreateView2Callback create_view_callback_;
+    fidl::ServerBindingGroup<fuchsia_ui_app::ViewProvider> bindings_;
+
+    async_dispatcher_t* const dispatcher_;
+};
+
+#endif  // FUCHSIA_FLATLAND_VIEW_H_
diff --git a/tools/Vulkan-Tools/cube/fuchsia/meta/vkcube-on-fb-protected.cml b/tools/Vulkan-Tools/cube/fuchsia/meta/vkcube-on-fb-protected.cml
new file mode 100644
index 00000000..43d51a6e
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/fuchsia/meta/vkcube-on-fb-protected.cml
@@ -0,0 +1,27 @@
+// Copyright (c) 2025 The Fuchsia Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+{
+    include: [
+        "//src/lib/vulkan/swapchain/VkLayer_image_pipe_swapchain_fb.shard.cml",
+        "sys/testing/elf_test_runner.shard.cml",
+    ],
+    program: {
+        binary: "bin/vkcube",
+        args: [
+            "--protected_output",
+            "--wsi",
+            "fuchsia_display",
+        ],
+    },
+}
diff --git a/tools/Vulkan-Tools/cube/fuchsia/meta/vkcube-on-fb.cml b/tools/Vulkan-Tools/cube/fuchsia/meta/vkcube-on-fb.cml
new file mode 100644
index 00000000..eaa78aae
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/fuchsia/meta/vkcube-on-fb.cml
@@ -0,0 +1,26 @@
+// Copyright (c) 2025 The Fuchsia Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+{
+    include: [
+        "//src/lib/vulkan/swapchain/VkLayer_image_pipe_swapchain_fb.shard.cml",
+        "sys/testing/elf_test_runner.shard.cml",
+    ],
+    program: {
+        binary: "bin/vkcube",
+        args: [
+            "--wsi",
+            "fuchsia_display",
+        ],
+    },
+}
diff --git a/tools/Vulkan-Tools/cube/fuchsia/meta/vkcube-on-scenic-protected.cml b/tools/Vulkan-Tools/cube/fuchsia/meta/vkcube-on-scenic-protected.cml
new file mode 100644
index 00000000..3138b605
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/fuchsia/meta/vkcube-on-scenic-protected.cml
@@ -0,0 +1,45 @@
+// Copyright (c) 2025 The Fuchsia Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+{
+    include: [ "//src/lib/vulkan/swapchain/VkLayer_image_pipe_swapchain.shard.cml" ],
+    program: {
+        runner: "elf",
+        binary: "bin/vkcube",
+        args: [
+            "--protected_output",
+            "--wsi",
+            "fuchsia_scenic",
+        ],
+    },
+    capabilities: [
+        {
+            protocol: [ "fuchsia.ui.app.ViewProvider" ],
+        },
+    ],
+    use: [
+        {
+            protocol: [
+                "fuchsia.ui.composition.Allocator",
+                "fuchsia.ui.composition.Flatland",
+            ],
+        },
+    ],
+    expose: [
+        {
+            protocol: [ "fuchsia.ui.app.ViewProvider" ],
+            from: "self",
+            to: "parent",
+        },
+    ],
+}
diff --git a/tools/Vulkan-Tools/cube/fuchsia/meta/vkcube-on-scenic.cml b/tools/Vulkan-Tools/cube/fuchsia/meta/vkcube-on-scenic.cml
new file mode 100644
index 00000000..cf940b5b
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/fuchsia/meta/vkcube-on-scenic.cml
@@ -0,0 +1,36 @@
+// Copyright (c) 2025 The Fuchsia Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+{
+    include: [ "//src/lib/vulkan/swapchain/VkLayer_image_pipe_swapchain.shard.cml" ],
+    program: {
+        runner: "elf",
+        binary: "bin/vkcube",
+        args: [
+            "--wsi",
+            "fuchsia_scenic",
+        ],
+    },
+    capabilities: [
+        {
+            protocol: [ "fuchsia.ui.app.ViewProvider" ],
+        },
+    ],
+    expose: [
+        {
+            protocol: [ "fuchsia.ui.app.ViewProvider" ],
+            from: "self",
+            to: "parent",
+        },
+    ],
+}
diff --git a/tools/Vulkan-Tools/cube/gettime.h b/tools/Vulkan-Tools/cube/gettime.h
new file mode 100644
index 00000000..0a697b42
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/gettime.h
@@ -0,0 +1,68 @@
+/**************************************************************************
+ *
+ * Copyright 2014, 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Ported from drawElements Utility Library (Google, Inc.)
+ * Port done by: Ian Elliott <ianelliott@google.com>
+ **************************************************************************/
+
+#include <time.h>
+#include <assert.h>
+#include <vulkan/vk_platform.h>
+
+#if defined(_WIN32)
+
+#include <windows.h>
+
+#elif defined(__unix__) || defined(__linux) || defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__ANDROID__) || defined(__EPOC32__) || defined(__QNX__) || defined(__APPLE__)
+
+#include <time.h>
+
+#endif
+
+uint64_t getTimeInNanoseconds(void) {
+    const long long ns_in_us = 1000;
+    const long long ns_in_ms = 1000 * ns_in_us;
+    const long long ns_in_s = 1000 * ns_in_ms;
+#if defined(_WIN32)
+    LARGE_INTEGER freq;
+    LARGE_INTEGER count;
+    QueryPerformanceCounter(&count);
+    QueryPerformanceFrequency(&freq);
+    assert(freq.LowPart != 0 || freq.HighPart != 0);
+
+    if (count.QuadPart < MAXLONGLONG / ns_in_s) {
+        assert(freq.QuadPart != 0);
+        return count.QuadPart * ns_in_s / freq.QuadPart;
+    } else {
+        assert(freq.QuadPart >= ns_in_s);
+        return count.QuadPart / (freq.QuadPart / ns_in_s);
+    }
+
+#elif defined(__unix__) || defined(__linux) || defined(__linux__) || defined(__ANDROID__) || defined(__QNX__) || defined(__APPLE__)
+    struct timespec currTime;
+    clock_gettime(CLOCK_MONOTONIC, &currTime);
+    return (uint64_t)currTime.tv_sec * ns_in_s + (uint64_t)currTime.tv_nsec;
+
+#elif defined(__EPOC32__)
+    struct timespec currTime;
+    /* Symbian supports only realtime clock for clock_gettime. */
+    clock_gettime(CLOCK_REALTIME, &currTime);
+    return (uint64_t)currTime.tv_sec * ns_in_s + (uint64_t)currTime.tv_nsec;
+
+#else
+#error getTimeInNanoseconds Not implemented for target OS
+#endif
+}
diff --git a/tools/Vulkan-Tools/cube/linmath.h b/tools/Vulkan-Tools/cube/linmath.h
new file mode 100644
index 00000000..6df1d7ee
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/linmath.h
@@ -0,0 +1,608 @@
+#ifndef LINMATH_H
+#define LINMATH_H
+
+#include <string.h>
+#include <math.h>
+#include <string.h>
+
+#ifdef LINMATH_NO_INLINE
+#define LINMATH_H_FUNC static
+#else
+#define LINMATH_H_FUNC static inline
+#endif
+
+#define degreesToRadians(angleDegrees) (angleDegrees * M_PI / 180.0)
+
+#define LINMATH_H_DEFINE_VEC(n) \
+typedef float vec##n[n]; \
+LINMATH_H_FUNC void vec##n##_add(vec##n r, vec##n const a, vec##n const b) \
+{ \
+	int i; \
+	for(i=0; i<n; ++i) \
+		r[i] = a[i] + b[i]; \
+} \
+LINMATH_H_FUNC void vec##n##_sub(vec##n r, vec##n const a, vec##n const b) \
+{ \
+	int i; \
+	for(i=0; i<n; ++i) \
+		r[i] = a[i] - b[i]; \
+} \
+LINMATH_H_FUNC void vec##n##_scale(vec##n r, vec##n const v, float const s) \
+{ \
+	int i; \
+	for(i=0; i<n; ++i) \
+		r[i] = v[i] * s; \
+} \
+LINMATH_H_FUNC float vec##n##_mul_inner(vec##n const a, vec##n const b) \
+{ \
+	float p = 0.f; \
+	int i; \
+	for(i=0; i<n; ++i) \
+		p += b[i]*a[i]; \
+	return p; \
+} \
+LINMATH_H_FUNC float vec##n##_len(vec##n const v) \
+{ \
+	return sqrtf(vec##n##_mul_inner(v,v)); \
+} \
+LINMATH_H_FUNC void vec##n##_norm(vec##n r, vec##n const v) \
+{ \
+	float k = 1.f / vec##n##_len(v); \
+	vec##n##_scale(r, v, k); \
+} \
+LINMATH_H_FUNC void vec##n##_min(vec##n r, vec##n const a, vec##n const b) \
+{ \
+	int i; \
+	for(i=0; i<n; ++i) \
+		r[i] = a[i]<b[i] ? a[i] : b[i]; \
+} \
+LINMATH_H_FUNC void vec##n##_max(vec##n r, vec##n const a, vec##n const b) \
+{ \
+	int i; \
+	for(i=0; i<n; ++i) \
+		r[i] = a[i]>b[i] ? a[i] : b[i]; \
+} \
+LINMATH_H_FUNC void vec##n##_dup(vec##n r, vec##n const src) \
+{ \
+	int i; \
+	for(i=0; i<n; ++i) \
+		r[i] = src[i]; \
+}
+
+LINMATH_H_DEFINE_VEC(2)
+LINMATH_H_DEFINE_VEC(3)
+LINMATH_H_DEFINE_VEC(4)
+
+LINMATH_H_FUNC void vec3_mul_cross(vec3 r, vec3 const a, vec3 const b)
+{
+	r[0] = a[1]*b[2] - a[2]*b[1];
+	r[1] = a[2]*b[0] - a[0]*b[2];
+	r[2] = a[0]*b[1] - a[1]*b[0];
+}
+
+LINMATH_H_FUNC void vec3_reflect(vec3 r, vec3 const v, vec3 const n)
+{
+	float p = 2.f * vec3_mul_inner(v, n);
+	int i;
+	for(i=0;i<3;++i)
+		r[i] = v[i] - p*n[i];
+}
+
+LINMATH_H_FUNC void vec4_mul_cross(vec4 r, vec4 const a, vec4 const b)
+{
+	r[0] = a[1]*b[2] - a[2]*b[1];
+	r[1] = a[2]*b[0] - a[0]*b[2];
+	r[2] = a[0]*b[1] - a[1]*b[0];
+	r[3] = 1.f;
+}
+
+LINMATH_H_FUNC void vec4_reflect(vec4 r, vec4 const v, vec4 const n)
+{
+	float p  = 2.f*vec4_mul_inner(v, n);
+	int i;
+	for(i=0;i<4;++i)
+		r[i] = v[i] - p*n[i];
+}
+
+typedef vec4 mat4x4[4];
+LINMATH_H_FUNC void mat4x4_identity(mat4x4 M)
+{
+	int i, j;
+	for(i=0; i<4; ++i)
+		for(j=0; j<4; ++j)
+			M[i][j] = i==j ? 1.f : 0.f;
+}
+LINMATH_H_FUNC void mat4x4_dup(mat4x4 M, mat4x4 const N)
+{
+	int i;
+	for(i=0; i<4; ++i)
+		vec4_dup(M[i], N[i]);
+}
+LINMATH_H_FUNC void mat4x4_row(vec4 r, mat4x4 const M, int i)
+{
+	int k;
+	for(k=0; k<4; ++k)
+		r[k] = M[k][i];
+}
+LINMATH_H_FUNC void mat4x4_col(vec4 r, mat4x4 const M, int i)
+{
+	int k;
+	for(k=0; k<4; ++k)
+		r[k] = M[i][k];
+}
+LINMATH_H_FUNC void mat4x4_transpose(mat4x4 M, mat4x4 const N)
+{
+    // Note: if M and N are the same, the user has to
+    // explicitly make a copy of M and set it to N.
+	int i, j;
+	for(j=0; j<4; ++j)
+		for(i=0; i<4; ++i)
+			M[i][j] = N[j][i];
+}
+LINMATH_H_FUNC void mat4x4_add(mat4x4 M, mat4x4 const a, mat4x4 const b)
+{
+	int i;
+	for(i=0; i<4; ++i)
+		vec4_add(M[i], a[i], b[i]);
+}
+LINMATH_H_FUNC void mat4x4_sub(mat4x4 M, mat4x4 const a, mat4x4 const b)
+{
+	int i;
+	for(i=0; i<4; ++i)
+		vec4_sub(M[i], a[i], b[i]);
+}
+LINMATH_H_FUNC void mat4x4_scale(mat4x4 M, mat4x4 const a, float k)
+{
+	int i;
+	for(i=0; i<4; ++i)
+		vec4_scale(M[i], a[i], k);
+}
+LINMATH_H_FUNC void mat4x4_scale_aniso(mat4x4 M, mat4x4 const a, float x, float y, float z)
+{
+	vec4_scale(M[0], a[0], x);
+	vec4_scale(M[1], a[1], y);
+	vec4_scale(M[2], a[2], z);
+	vec4_dup(M[3], a[3]);
+}
+LINMATH_H_FUNC void mat4x4_mul(mat4x4 M, mat4x4 const a, mat4x4 const b)
+{
+	mat4x4 temp;
+	int k, r, c;
+	for(c=0; c<4; ++c) for(r=0; r<4; ++r) {
+		temp[c][r] = 0.f;
+		for(k=0; k<4; ++k)
+			temp[c][r] += a[k][r] * b[c][k];
+	}
+	mat4x4_dup(M, temp);
+}
+LINMATH_H_FUNC void mat4x4_mul_vec4(vec4 r, mat4x4 const M, vec4 const v)
+{
+	int i, j;
+	for(j=0; j<4; ++j) {
+		r[j] = 0.f;
+		for(i=0; i<4; ++i)
+			r[j] += M[i][j] * v[i];
+	}
+}
+LINMATH_H_FUNC void mat4x4_translate(mat4x4 T, float x, float y, float z)
+{
+	mat4x4_identity(T);
+	T[3][0] = x;
+	T[3][1] = y;
+	T[3][2] = z;
+}
+LINMATH_H_FUNC void mat4x4_translate_in_place(mat4x4 M, float x, float y, float z)
+{
+	vec4 t = {x, y, z, 0};
+	vec4 r;
+	int i;
+	for (i = 0; i < 4; ++i) {
+		mat4x4_row(r, M, i);
+		M[3][i] += vec4_mul_inner(r, t);
+	}
+}
+LINMATH_H_FUNC void mat4x4_from_vec3_mul_outer(mat4x4 M, vec3 const a, vec3 const b)
+{
+	int i, j;
+	for(i=0; i<4; ++i) for(j=0; j<4; ++j)
+		M[i][j] = i<3 && j<3 ? a[i] * b[j] : 0.f;
+}
+LINMATH_H_FUNC void mat4x4_rotate(mat4x4 R, mat4x4 const M, float x, float y, float z, float angle)
+{
+	float s = sinf(angle);
+	float c = cosf(angle);
+	vec3 u = {x, y, z};
+
+	if(vec3_len(u) > 1e-4) {
+		vec3_norm(u, u);
+		mat4x4 T;
+		mat4x4_from_vec3_mul_outer(T, u, u);
+
+		mat4x4 S = {
+			{    0,  u[2], -u[1], 0},
+			{-u[2],     0,  u[0], 0},
+			{ u[1], -u[0],     0, 0},
+			{    0,     0,     0, 0}
+		};
+		mat4x4_scale(S, S, s);
+
+		mat4x4 C;
+		mat4x4_identity(C);
+		mat4x4_sub(C, C, T);
+
+		mat4x4_scale(C, C, c);
+
+		mat4x4_add(T, T, C);
+		mat4x4_add(T, T, S);
+
+		T[3][3] = 1.f;
+		mat4x4_mul(R, M, T);
+	} else {
+		mat4x4_dup(R, M);
+	}
+}
+LINMATH_H_FUNC void mat4x4_rotate_X(mat4x4 Q, mat4x4 const M, float angle)
+{
+	float s = sinf(angle);
+	float c = cosf(angle);
+	mat4x4 R = {
+		{1.f, 0.f, 0.f, 0.f},
+		{0.f,   c,   s, 0.f},
+		{0.f,  -s,   c, 0.f},
+		{0.f, 0.f, 0.f, 1.f}
+	};
+	mat4x4_mul(Q, M, R);
+}
+LINMATH_H_FUNC void mat4x4_rotate_Y(mat4x4 Q, mat4x4 const M, float angle)
+{
+	float s = sinf(angle);
+	float c = cosf(angle);
+	mat4x4 R = {
+		{   c, 0.f,  -s, 0.f},
+		{ 0.f, 1.f, 0.f, 0.f},
+		{   s, 0.f,   c, 0.f},
+		{ 0.f, 0.f, 0.f, 1.f}
+	};
+	mat4x4_mul(Q, M, R);
+}
+LINMATH_H_FUNC void mat4x4_rotate_Z(mat4x4 Q, mat4x4 const M, float angle)
+{
+	float s = sinf(angle);
+	float c = cosf(angle);
+	mat4x4 R = {
+		{   c,   s, 0.f, 0.f},
+		{  -s,   c, 0.f, 0.f},
+		{ 0.f, 0.f, 1.f, 0.f},
+		{ 0.f, 0.f, 0.f, 1.f}
+	};
+	mat4x4_mul(Q, M, R);
+}
+LINMATH_H_FUNC void mat4x4_invert(mat4x4 T, mat4x4 const M)
+{
+	float s[6];
+	float c[6];
+	s[0] = M[0][0]*M[1][1] - M[1][0]*M[0][1];
+	s[1] = M[0][0]*M[1][2] - M[1][0]*M[0][2];
+	s[2] = M[0][0]*M[1][3] - M[1][0]*M[0][3];
+	s[3] = M[0][1]*M[1][2] - M[1][1]*M[0][2];
+	s[4] = M[0][1]*M[1][3] - M[1][1]*M[0][3];
+	s[5] = M[0][2]*M[1][3] - M[1][2]*M[0][3];
+
+	c[0] = M[2][0]*M[3][1] - M[3][0]*M[2][1];
+	c[1] = M[2][0]*M[3][2] - M[3][0]*M[2][2];
+	c[2] = M[2][0]*M[3][3] - M[3][0]*M[2][3];
+	c[3] = M[2][1]*M[3][2] - M[3][1]*M[2][2];
+	c[4] = M[2][1]*M[3][3] - M[3][1]*M[2][3];
+	c[5] = M[2][2]*M[3][3] - M[3][2]*M[2][3];
+
+	/* Assumes it is invertible */
+	float idet = 1.0f/( s[0]*c[5]-s[1]*c[4]+s[2]*c[3]+s[3]*c[2]-s[4]*c[1]+s[5]*c[0] );
+
+	T[0][0] = ( M[1][1] * c[5] - M[1][2] * c[4] + M[1][3] * c[3]) * idet;
+	T[0][1] = (-M[0][1] * c[5] + M[0][2] * c[4] - M[0][3] * c[3]) * idet;
+	T[0][2] = ( M[3][1] * s[5] - M[3][2] * s[4] + M[3][3] * s[3]) * idet;
+	T[0][3] = (-M[2][1] * s[5] + M[2][2] * s[4] - M[2][3] * s[3]) * idet;
+
+	T[1][0] = (-M[1][0] * c[5] + M[1][2] * c[2] - M[1][3] * c[1]) * idet;
+	T[1][1] = ( M[0][0] * c[5] - M[0][2] * c[2] + M[0][3] * c[1]) * idet;
+	T[1][2] = (-M[3][0] * s[5] + M[3][2] * s[2] - M[3][3] * s[1]) * idet;
+	T[1][3] = ( M[2][0] * s[5] - M[2][2] * s[2] + M[2][3] * s[1]) * idet;
+
+	T[2][0] = ( M[1][0] * c[4] - M[1][1] * c[2] + M[1][3] * c[0]) * idet;
+	T[2][1] = (-M[0][0] * c[4] + M[0][1] * c[2] - M[0][3] * c[0]) * idet;
+	T[2][2] = ( M[3][0] * s[4] - M[3][1] * s[2] + M[3][3] * s[0]) * idet;
+	T[2][3] = (-M[2][0] * s[4] + M[2][1] * s[2] - M[2][3] * s[0]) * idet;
+
+	T[3][0] = (-M[1][0] * c[3] + M[1][1] * c[1] - M[1][2] * c[0]) * idet;
+	T[3][1] = ( M[0][0] * c[3] - M[0][1] * c[1] + M[0][2] * c[0]) * idet;
+	T[3][2] = (-M[3][0] * s[3] + M[3][1] * s[1] - M[3][2] * s[0]) * idet;
+	T[3][3] = ( M[2][0] * s[3] - M[2][1] * s[1] + M[2][2] * s[0]) * idet;
+}
+LINMATH_H_FUNC void mat4x4_orthonormalize(mat4x4 R, mat4x4 const M)
+{
+	mat4x4_dup(R, M);
+	float s = 1.f;
+	vec3 h;
+
+	vec3_norm(R[2], R[2]);
+
+	s = vec3_mul_inner(R[1], R[2]);
+	vec3_scale(h, R[2], s);
+	vec3_sub(R[1], R[1], h);
+	vec3_norm(R[1], R[1]);
+
+	s = vec3_mul_inner(R[0], R[2]);
+	vec3_scale(h, R[2], s);
+	vec3_sub(R[0], R[0], h);
+
+	s = vec3_mul_inner(R[0], R[1]);
+	vec3_scale(h, R[1], s);
+	vec3_sub(R[0], R[0], h);
+	vec3_norm(R[0], R[0]);
+}
+
+LINMATH_H_FUNC void mat4x4_frustum(mat4x4 M, float l, float r, float b, float t, float n, float f)
+{
+	M[0][0] = 2.f*n/(r-l);
+	M[0][1] = M[0][2] = M[0][3] = 0.f;
+
+	M[1][1] = 2.f*n/(t-b);
+	M[1][0] = M[1][2] = M[1][3] = 0.f;
+
+	M[2][0] = (r+l)/(r-l);
+	M[2][1] = (t+b)/(t-b);
+	M[2][2] = -(f+n)/(f-n);
+	M[2][3] = -1.f;
+
+	M[3][2] = -2.f*(f*n)/(f-n);
+	M[3][0] = M[3][1] = M[3][3] = 0.f;
+}
+LINMATH_H_FUNC void mat4x4_ortho(mat4x4 M, float l, float r, float b, float t, float n, float f)
+{
+	M[0][0] = 2.f/(r-l);
+	M[0][1] = M[0][2] = M[0][3] = 0.f;
+
+	M[1][1] = 2.f/(t-b);
+	M[1][0] = M[1][2] = M[1][3] = 0.f;
+
+	M[2][2] = -2.f/(f-n);
+	M[2][0] = M[2][1] = M[2][3] = 0.f;
+
+	M[3][0] = -(r+l)/(r-l);
+	M[3][1] = -(t+b)/(t-b);
+	M[3][2] = -(f+n)/(f-n);
+	M[3][3] = 1.f;
+}
+LINMATH_H_FUNC void mat4x4_perspective(mat4x4 m, float y_fov, float aspect, float n, float f)
+{
+	/* NOTE: Degrees are an unhandy unit to work with.
+	 * linmath.h uses radians for everything! */
+	float const a = 1.f / tanf(y_fov / 2.f);
+
+	m[0][0] = a / aspect;
+	m[0][1] = 0.f;
+	m[0][2] = 0.f;
+	m[0][3] = 0.f;
+
+	m[1][0] = 0.f;
+	m[1][1] = a;
+	m[1][2] = 0.f;
+	m[1][3] = 0.f;
+
+	m[2][0] = 0.f;
+	m[2][1] = 0.f;
+	m[2][2] = -((f + n) / (f - n));
+	m[2][3] = -1.f;
+
+	m[3][0] = 0.f;
+	m[3][1] = 0.f;
+	m[3][2] = -((2.f * f * n) / (f - n));
+	m[3][3] = 0.f;
+}
+LINMATH_H_FUNC void mat4x4_look_at(mat4x4 m, vec3 const eye, vec3 const center, vec3 const up)
+{
+	/* Adapted from Android's OpenGL Matrix.java.                        */
+	/* See the OpenGL GLUT documentation for gluLookAt for a description */
+	/* of the algorithm. We implement it in a straightforward way:       */
+
+	/* TODO: The negation of of can be spared by swapping the order of
+	 *       operands in the following cross products in the right way. */
+	vec3 f;
+	vec3_sub(f, center, eye);
+	vec3_norm(f, f);
+
+	vec3 s;
+	vec3_mul_cross(s, f, up);
+	vec3_norm(s, s);
+
+	vec3 t;
+	vec3_mul_cross(t, s, f);
+
+	m[0][0] =  s[0];
+	m[0][1] =  t[0];
+	m[0][2] = -f[0];
+	m[0][3] =   0.f;
+
+	m[1][0] =  s[1];
+	m[1][1] =  t[1];
+	m[1][2] = -f[1];
+	m[1][3] =   0.f;
+
+	m[2][0] =  s[2];
+	m[2][1] =  t[2];
+	m[2][2] = -f[2];
+	m[2][3] =   0.f;
+
+	m[3][0] =  0.f;
+	m[3][1] =  0.f;
+	m[3][2] =  0.f;
+	m[3][3] =  1.f;
+
+	mat4x4_translate_in_place(m, -eye[0], -eye[1], -eye[2]);
+}
+
+typedef float quat[4];
+#define quat_add vec4_add
+#define quat_sub vec4_sub
+#define quat_norm vec4_norm
+#define quat_scale vec4_scale
+#define quat_mul_inner vec4_mul_inner
+
+LINMATH_H_FUNC void quat_identity(quat q)
+{
+	q[0] = q[1] = q[2] = 0.f;
+	q[3] = 1.f;
+}
+LINMATH_H_FUNC void quat_mul(quat r, quat const p, quat const q)
+{
+	vec3 w, tmp;
+
+	vec3_mul_cross(tmp, p, q);
+	vec3_scale(w, p, q[3]);
+	vec3_add(tmp, tmp, w);
+	vec3_scale(w, q, p[3]);
+	vec3_add(tmp, tmp, w);
+
+	vec3_dup(r, tmp);
+	r[3] = p[3]*q[3] - vec3_mul_inner(p, q);
+}
+LINMATH_H_FUNC void quat_conj(quat r, quat const q)
+{
+	int i;
+	for(i=0; i<3; ++i)
+		r[i] = -q[i];
+	r[3] = q[3];
+}
+LINMATH_H_FUNC void quat_rotate(quat r, float angle, vec3 const axis) {
+    vec3 axis_norm;
+    vec3_norm(axis_norm, axis);
+    float s = sinf(angle / 2);
+    float c = cosf(angle / 2);
+    vec3_scale(r, axis_norm, s);
+    r[3] = c;
+}
+LINMATH_H_FUNC void quat_mul_vec3(vec3 r, quat const q, vec3 const v)
+{
+/*
+ * Method by Fabian 'ryg' Giessen (of Farbrausch)
+t = 2 * cross(q.xyz, v)
+v' = v + q.w * t + cross(q.xyz, t)
+ */
+	vec3 t;
+	vec3 q_xyz = {q[0], q[1], q[2]};
+	vec3 u = {q[0], q[1], q[2]};
+
+	vec3_mul_cross(t, q_xyz, v);
+	vec3_scale(t, t, 2);
+
+	vec3_mul_cross(u, q_xyz, t);
+	vec3_scale(t, t, q[3]);
+
+	vec3_add(r, v, t);
+	vec3_add(r, r, u);
+}
+LINMATH_H_FUNC void mat4x4_from_quat(mat4x4 M, quat const q)
+{
+	float a = q[3];
+	float b = q[0];
+	float c = q[1];
+	float d = q[2];
+	float a2 = a*a;
+	float b2 = b*b;
+	float c2 = c*c;
+	float d2 = d*d;
+
+	M[0][0] = a2 + b2 - c2 - d2;
+	M[0][1] = 2.f*(b*c + a*d);
+	M[0][2] = 2.f*(b*d - a*c);
+	M[0][3] = 0.f;
+
+	M[1][0] = 2*(b*c - a*d);
+	M[1][1] = a2 - b2 + c2 - d2;
+	M[1][2] = 2.f*(c*d + a*b);
+	M[1][3] = 0.f;
+
+	M[2][0] = 2.f*(b*d + a*c);
+	M[2][1] = 2.f*(c*d - a*b);
+	M[2][2] = a2 - b2 - c2 + d2;
+	M[2][3] = 0.f;
+
+	M[3][0] = M[3][1] = M[3][2] = 0.f;
+	M[3][3] = 1.f;
+}
+
+LINMATH_H_FUNC void mat4x4o_mul_quat(mat4x4 R, mat4x4 const M, quat const q)
+{
+/*  XXX: The way this is written only works for orthogonal matrices. */
+/* TODO: Take care of non-orthogonal case. */
+	quat_mul_vec3(R[0], q, M[0]);
+	quat_mul_vec3(R[1], q, M[1]);
+	quat_mul_vec3(R[2], q, M[2]);
+
+	R[3][0] = R[3][1] = R[3][2] = 0.f;
+	R[0][3] = M[0][3];
+	R[1][3] = M[1][3];
+	R[2][3] = M[2][3];
+	R[3][3] = M[3][3];  // typically 1.0, but here we make it general
+}
+LINMATH_H_FUNC void quat_from_mat4x4(quat q, mat4x4 const M)
+{
+	float r=0.f;
+	int i;
+
+	int perm[] = { 0, 1, 2, 0, 1 };
+	int *p = perm;
+
+	for(i = 0; i<3; i++) {
+		float m = M[i][i];
+		if( m < r )
+			continue;
+		m = r;
+		p = &perm[i];
+	}
+
+	r = sqrtf(1.f + M[p[0]][p[0]] - M[p[1]][p[1]] - M[p[2]][p[2]] );
+
+	if(r < 1e-6) {
+		q[0] = 1.f;
+		q[1] = q[2] = q[3] = 0.f;
+		return;
+	}
+
+	q[0] = r/2.f;
+	q[1] = (M[p[0]][p[1]] - M[p[1]][p[0]])/(2.f*r);
+	q[2] = (M[p[2]][p[0]] - M[p[0]][p[2]])/(2.f*r);
+	q[3] = (M[p[2]][p[1]] - M[p[1]][p[2]])/(2.f*r);
+}
+
+LINMATH_H_FUNC void mat4x4_arcball(mat4x4 R, mat4x4 const M, vec2 const _a, vec2 const _b, float s)
+{
+	vec2 a; memcpy(a, _a, sizeof(a));
+	vec2 b; memcpy(b, _b, sizeof(b));
+
+	float z_a = 0.;
+	float z_b = 0.;
+
+	if(vec2_len(a) < 1.) {
+		z_a = sqrtf(1.f - vec2_mul_inner(a, a));
+	} else {
+		vec2_norm(a, a);
+	}
+
+	if(vec2_len(b) < 1.) {
+		z_b = sqrtf(1.f - vec2_mul_inner(b, b));
+	} else {
+		vec2_norm(b, b);
+	}
+
+	vec3 a_ = {a[0], a[1], z_a};
+	vec3 b_ = {b[0], b[1], z_b};
+
+	vec3 c_;
+	vec3_mul_cross(c_, a_, b_);
+
+	float const angle = acosf(vec3_mul_inner(a_, b_)) * s;
+	mat4x4_rotate(R, M, c_[0], c_[1], c_[2], angle);
+}
+
+#endif
diff --git a/tools/Vulkan-Tools/cube/lunarg.ppm.h b/tools/Vulkan-Tools/cube/lunarg.ppm.h
new file mode 100644
index 00000000..038a8c51
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/lunarg.ppm.h
@@ -0,0 +1,9365 @@
+static unsigned char lunarg_ppm[] = {
+    0x50, 0x36, 0x0a, 0x32, 0x35, 0x36, 0x20, 0x32, 0x35, 0x36, 0x0a, 0x32, 0x35, 0x35, 0x0a, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b,
+    0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b,
+    0x7b, 0x7b, 0x7b, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7b, 0x7b, 0x7b,
+    0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7b, 0x7b, 0x7b,
+    0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d,
+    0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d,
+    0x7d, 0x7d, 0x7d, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d,
+    0x7d, 0x7d, 0x7d, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e,
+    0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d,
+    0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e,
+    0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f,
+    0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+    0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e,
+    0x7e, 0x7e, 0x7e, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e,
+    0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+    0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+    0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e,
+    0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7b, 0x7b, 0x7b, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7e, 0x7e, 0x7e,
+    0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x81, 0x81, 0x81,
+    0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+    0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7e, 0x7e, 0x7e,
+    0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7b, 0x7b, 0x7b, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d,
+    0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+    0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+    0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+    0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x80, 0x80, 0x80,
+    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7e, 0x7e, 0x7e,
+    0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7b, 0x7b, 0x7b, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7d, 0x7d, 0x7d,
+    0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+    0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+    0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+    0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+    0x84, 0x84, 0x84, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+    0x83, 0x83, 0x83, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7e, 0x7e, 0x7e,
+    0x7e, 0x7e, 0x7e, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7b, 0x7b, 0x7b, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f,
+    0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+    0x81, 0x81, 0x81, 0x82, 0x82, 0x82, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+    0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+    0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+    0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+    0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e,
+    0x7e, 0x7e, 0x7e, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7b, 0x7b, 0x7b,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7b, 0x7b, 0x7b,
+    0x7b, 0x7b, 0x7b, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7e, 0x7e, 0x7e,
+    0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x81, 0x81, 0x81,
+    0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x82, 0x82, 0x82, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+    0x84, 0x84, 0x84, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x86, 0x86, 0x86,
+    0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+    0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x85, 0x85, 0x85,
+    0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+    0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x82, 0x82, 0x82, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x80, 0x80, 0x80,
+    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7d, 0x7d, 0x7d,
+    0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x69, 0x74, 0x75, 0x33, 0x6d, 0x75, 0x14, 0x65, 0x71,
+    0x0f, 0x62, 0x6e, 0x0f, 0x62, 0x6e, 0x0f, 0x62, 0x6e, 0x0f, 0x62, 0x6e, 0x0f, 0x62, 0x6e, 0x0f, 0x62, 0x6e, 0x0f, 0x62, 0x6e,
+    0x0f, 0x62, 0x6e, 0x0f, 0x62, 0x6e, 0x0f, 0x62, 0x6e, 0x0f, 0x62, 0x6e, 0x0f, 0x62, 0x6e, 0x0f, 0x62, 0x6e, 0x0f, 0x62, 0x6e,
+    0x0f, 0x62, 0x6e, 0x0f, 0x62, 0x6e, 0x0f, 0x62, 0x6e, 0x0f, 0x62, 0x6e, 0x0f, 0x62, 0x6e, 0x0f, 0x62, 0x6e, 0x0f, 0x62, 0x6e,
+    0x0f, 0x62, 0x6e, 0x0f, 0x62, 0x6d, 0x0f, 0x62, 0x6d, 0x0f, 0x62, 0x6d, 0x0f, 0x61, 0x6d, 0x0f, 0x61, 0x6d, 0x0f, 0x61, 0x6d,
+    0x0f, 0x61, 0x6d, 0x0f, 0x61, 0x6d, 0x0f, 0x61, 0x6d, 0x0f, 0x61, 0x6d, 0x0f, 0x61, 0x6d, 0x0f, 0x61, 0x6d, 0x0f, 0x61, 0x6c,
+    0x0f, 0x61, 0x6c, 0x0f, 0x60, 0x6c, 0x0f, 0x60, 0x6c, 0x0f, 0x60, 0x6c, 0x0f, 0x60, 0x6c, 0x0f, 0x60, 0x6c, 0x0f, 0x60, 0x6c,
+    0x0f, 0x60, 0x6c, 0x0f, 0x60, 0x6b, 0x0f, 0x5f, 0x6b, 0x0f, 0x5f, 0x6b, 0x0f, 0x5f, 0x6b, 0x0f, 0x5f, 0x6b, 0x0f, 0x5f, 0x6b,
+    0x0f, 0x5f, 0x6a, 0x0f, 0x5f, 0x6a, 0x0f, 0x5e, 0x6a, 0x0f, 0x5e, 0x69, 0x0f, 0x5e, 0x69, 0x0f, 0x5e, 0x69, 0x0f, 0x5d, 0x69,
+    0x0d, 0x5d, 0x68, 0x0d, 0x5d, 0x68, 0x0d, 0x5d, 0x68, 0x0d, 0x5c, 0x68, 0x0d, 0x5c, 0x67, 0x0d, 0x5c, 0x67, 0x0d, 0x5c, 0x67,
+    0x0d, 0x5b, 0x66, 0x0d, 0x5b, 0x66, 0x0d, 0x5b, 0x66, 0x0d, 0x5a, 0x65, 0x0d, 0x5a, 0x65, 0x0d, 0x59, 0x64, 0x0e, 0x59, 0x64,
+    0x0e, 0x59, 0x63, 0x0e, 0x59, 0x63, 0x0e, 0x59, 0x62, 0x0e, 0x59, 0x62, 0x0e, 0x57, 0x61, 0x0e, 0x58, 0x60, 0x0f, 0x57, 0x5f,
+    0x0f, 0x57, 0x5f, 0x0e, 0x56, 0x5f, 0x0d, 0x56, 0x5f, 0x0d, 0x55, 0x5f, 0x0d, 0x54, 0x5e, 0x0d, 0x54, 0x5d, 0x0e, 0x53, 0x5e,
+    0x0e, 0x53, 0x5d, 0x0e, 0x52, 0x5c, 0x0e, 0x52, 0x5c, 0x0e, 0x51, 0x5b, 0x0e, 0x52, 0x5a, 0x0e, 0x51, 0x5a, 0x0e, 0x4f, 0x58,
+    0x0e, 0x4f, 0x57, 0x0e, 0x4e, 0x56, 0x0e, 0x4d, 0x56, 0x0f, 0x4c, 0x56, 0x0f, 0x4c, 0x55, 0x0d, 0x4b, 0x53, 0x0d, 0x4a, 0x53,
+    0x0d, 0x4a, 0x51, 0x0e, 0x4a, 0x51, 0x0e, 0x49, 0x51, 0x0d, 0x48, 0x50, 0x0d, 0x47, 0x4f, 0x0d, 0x46, 0x4e, 0x0d, 0x46, 0x4d,
+    0x0d, 0x44, 0x4b, 0x0d, 0x43, 0x4b, 0x0d, 0x42, 0x4b, 0x0d, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46,
+    0x0c, 0x3e, 0x45, 0x0c, 0x3d, 0x43, 0x09, 0x37, 0x3f, 0x41, 0x69, 0x6e, 0xd7, 0xe4, 0xe6, 0xc4, 0xd7, 0xda, 0x5b, 0x91, 0x98,
+    0x46, 0x81, 0x8a, 0x46, 0x80, 0x89, 0x46, 0x80, 0x89, 0x46, 0x80, 0x89, 0x45, 0x80, 0x89, 0x45, 0x80, 0x89, 0x43, 0x7e, 0x88,
+    0x43, 0x7d, 0x86, 0x43, 0x7d, 0x86, 0x42, 0x7c, 0x85, 0x41, 0x7b, 0x84, 0x41, 0x7b, 0x84, 0x40, 0x7a, 0x84, 0x3f, 0x79, 0x83,
+    0x3e, 0x78, 0x82, 0x3d, 0x78, 0x81, 0x3c, 0x77, 0x80, 0x3b, 0x76, 0x7f, 0x3b, 0x76, 0x7f, 0x3a, 0x74, 0x7d, 0x39, 0x74, 0x7d,
+    0x38, 0x71, 0x7b, 0x37, 0x71, 0x7b, 0x36, 0x70, 0x7a, 0x35, 0x6f, 0x79, 0x34, 0x6f, 0x77, 0x33, 0x6f, 0x77, 0x32, 0x6c, 0x76,
+    0x32, 0x6b, 0x75, 0x31, 0x6b, 0x75, 0x2f, 0x69, 0x73, 0x2f, 0x69, 0x71, 0x2e, 0x68, 0x71, 0x2d, 0x68, 0x70, 0x2d, 0x67, 0x6f,
+    0x2c, 0x65, 0x6f, 0x2a, 0x64, 0x6d, 0x2a, 0x64, 0x6c, 0x29, 0x63, 0x6c, 0x29, 0x62, 0x6b, 0x28, 0x62, 0x6a, 0x27, 0x60, 0x69,
+    0x27, 0x60, 0x69, 0x27, 0x60, 0x69, 0x26, 0x5e, 0x67, 0x26, 0x5e, 0x67, 0x26, 0x5e, 0x65, 0x25, 0x5d, 0x64, 0x25, 0x5d, 0x64,
+    0x24, 0x5b, 0x63, 0x23, 0x5a, 0x63, 0x23, 0x59, 0x63, 0x23, 0x59, 0x62, 0x23, 0x58, 0x61, 0x22, 0x58, 0x61, 0x22, 0x57, 0x60,
+    0x22, 0x57, 0x60, 0x22, 0x56, 0x5f, 0x22, 0x56, 0x5f, 0x22, 0x55, 0x5d, 0x21, 0x55, 0x5d, 0x20, 0x53, 0x5b, 0x20, 0x52, 0x5b,
+    0x20, 0x52, 0x5b, 0x20, 0x52, 0x5b, 0x20, 0x52, 0x5a, 0x1f, 0x51, 0x59, 0x1f, 0x51, 0x59, 0x1f, 0x50, 0x58, 0x1e, 0x4f, 0x57,
+    0x1e, 0x4f, 0x57, 0x1e, 0x4d, 0x55, 0x1e, 0x4d, 0x55, 0x1e, 0x4d, 0x54, 0x1e, 0x4c, 0x54, 0x1d, 0x4c, 0x53, 0x1d, 0x4b, 0x52,
+    0x1c, 0x4a, 0x51, 0x1d, 0x4a, 0x51, 0x1d, 0x49, 0x50, 0x1d, 0x48, 0x4f, 0x1c, 0x47, 0x4e, 0x1c, 0x47, 0x4e, 0x1c, 0x46, 0x4d,
+    0x1c, 0x46, 0x4c, 0x1b, 0x45, 0x4b, 0x1b, 0x44, 0x4b, 0x1b, 0x43, 0x4a, 0x1b, 0x43, 0x49, 0x26, 0x4c, 0x52, 0x49, 0x62, 0x67,
+    0x72, 0x73, 0x73, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x56, 0x72, 0x76, 0x0c, 0x61, 0x6d, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62,
+    0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f,
+    0x06, 0x54, 0x5f, 0x06, 0x53, 0x5f, 0x05, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x53, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5c,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58,
+    0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54,
+    0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x51, 0x05, 0x48, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x50, 0x05, 0x46, 0x4f,
+    0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4c, 0x04, 0x43, 0x4b, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x49, 0x04, 0x40, 0x49,
+    0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3d, 0x45, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x39, 0x41,
+    0x04, 0x38, 0x40, 0x04, 0x38, 0x3f, 0x04, 0x36, 0x3e, 0x04, 0x35, 0x3d, 0x04, 0x34, 0x3c, 0x04, 0x33, 0x3a, 0x03, 0x32, 0x39,
+    0x03, 0x31, 0x38, 0x03, 0x30, 0x36, 0x03, 0x2f, 0x35, 0x03, 0x2e, 0x34, 0x03, 0x2c, 0x32, 0x03, 0x2b, 0x31, 0x03, 0x29, 0x2f,
+    0x00, 0x25, 0x2a, 0x5a, 0x7a, 0x7e, 0xff, 0xff, 0xff, 0xdc, 0xe9, 0xeb, 0x52, 0x90, 0x9a, 0x38, 0x7f, 0x8a, 0x38, 0x7f, 0x8a,
+    0x37, 0x7e, 0x89, 0x37, 0x7e, 0x89, 0x36, 0x7c, 0x88, 0x36, 0x7c, 0x88, 0x35, 0x7b, 0x86, 0x34, 0x7a, 0x85, 0x34, 0x7a, 0x84,
+    0x33, 0x79, 0x83, 0x32, 0x77, 0x83, 0x31, 0x77, 0x81, 0x30, 0x75, 0x81, 0x30, 0x75, 0x80, 0x2f, 0x74, 0x7e, 0x2e, 0x73, 0x7e,
+    0x2d, 0x72, 0x7c, 0x2c, 0x71, 0x7c, 0x2b, 0x70, 0x7a, 0x2a, 0x6e, 0x79, 0x29, 0x6d, 0x78, 0x27, 0x6d, 0x77, 0x26, 0x6b, 0x76,
+    0x26, 0x6a, 0x75, 0x25, 0x69, 0x73, 0x24, 0x68, 0x73, 0x23, 0x67, 0x71, 0x22, 0x65, 0x70, 0x21, 0x64, 0x6f, 0x1f, 0x62, 0x6d,
+    0x1e, 0x61, 0x6c, 0x1d, 0x60, 0x6b, 0x1c, 0x5f, 0x6a, 0x1c, 0x5f, 0x6a, 0x1b, 0x5e, 0x68, 0x1a, 0x5c, 0x67, 0x19, 0x5a, 0x65,
+    0x19, 0x5a, 0x65, 0x18, 0x59, 0x63, 0x18, 0x59, 0x62, 0x17, 0x57, 0x61, 0x17, 0x56, 0x61, 0x16, 0x55, 0x5f, 0x16, 0x54, 0x5e,
+    0x15, 0x53, 0x5d, 0x14, 0x52, 0x5c, 0x13, 0x50, 0x5a, 0x13, 0x50, 0x5a, 0x13, 0x4f, 0x59, 0x12, 0x4e, 0x57, 0x12, 0x4d, 0x57,
+    0x12, 0x4c, 0x56, 0x11, 0x4b, 0x55, 0x10, 0x4b, 0x54, 0x10, 0x4a, 0x53, 0x10, 0x4a, 0x53, 0x10, 0x49, 0x52, 0x10, 0x48, 0x51,
+    0x10, 0x47, 0x50, 0x0f, 0x46, 0x4f, 0x0f, 0x45, 0x4e, 0x0e, 0x43, 0x4c, 0x0e, 0x43, 0x4b, 0x0e, 0x43, 0x4b, 0x0e, 0x42, 0x4a,
+    0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3e, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43,
+    0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x38, 0x3e, 0x0c, 0x37, 0x3d, 0x0b, 0x36, 0x3c,
+    0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x33, 0x3a, 0x0b, 0x32, 0x39, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35,
+    0x0a, 0x2e, 0x34, 0x0a, 0x2d, 0x33, 0x0a, 0x2c, 0x32, 0x09, 0x2b, 0x31, 0x21, 0x46, 0x4c, 0x69, 0x70, 0x71, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x63, 0x73, 0x76, 0x0b, 0x60, 0x6d, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61,
+    0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e,
+    0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b,
+    0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57,
+    0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53,
+    0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d,
+    0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47,
+    0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f,
+    0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37,
+    0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x01, 0x29, 0x2f, 0x00, 0x23, 0x29, 0x69, 0x87, 0x8b,
+    0xff, 0xff, 0xff, 0xe0, 0xec, 0xed, 0x55, 0x93, 0x9c, 0x3b, 0x81, 0x8c, 0x3b, 0x81, 0x8b, 0x3a, 0x81, 0x8b, 0x39, 0x7f, 0x8a,
+    0x39, 0x7e, 0x89, 0x38, 0x7e, 0x89, 0x37, 0x7d, 0x87, 0x37, 0x7c, 0x87, 0x36, 0x7c, 0x87, 0x35, 0x7b, 0x85, 0x34, 0x7a, 0x85,
+    0x33, 0x79, 0x83, 0x31, 0x77, 0x82, 0x31, 0x76, 0x81, 0x30, 0x75, 0x80, 0x2f, 0x75, 0x7f, 0x2e, 0x73, 0x7e, 0x2d, 0x72, 0x7c,
+    0x2c, 0x71, 0x7c, 0x2b, 0x70, 0x7a, 0x2a, 0x6f, 0x7a, 0x28, 0x6d, 0x78, 0x26, 0x6c, 0x76, 0x26, 0x6b, 0x76, 0x25, 0x6a, 0x74,
+    0x24, 0x68, 0x74, 0x23, 0x67, 0x72, 0x22, 0x66, 0x71, 0x21, 0x65, 0x6f, 0x20, 0x64, 0x6e, 0x1f, 0x62, 0x6e, 0x1e, 0x62, 0x6d,
+    0x1d, 0x61, 0x6c, 0x1c, 0x5f, 0x6b, 0x1b, 0x5f, 0x69, 0x1a, 0x5d, 0x68, 0x1a, 0x5d, 0x68, 0x19, 0x5b, 0x66, 0x19, 0x5a, 0x64,
+    0x18, 0x5a, 0x63, 0x17, 0x58, 0x63, 0x17, 0x58, 0x62, 0x16, 0x56, 0x60, 0x16, 0x55, 0x60, 0x15, 0x54, 0x5f, 0x15, 0x54, 0x5e,
+    0x14, 0x52, 0x5c, 0x14, 0x52, 0x5c, 0x13, 0x51, 0x5b, 0x12, 0x4f, 0x59, 0x12, 0x4e, 0x58, 0x12, 0x4e, 0x57, 0x12, 0x4d, 0x57,
+    0x11, 0x4c, 0x56, 0x11, 0x4c, 0x55, 0x10, 0x4b, 0x54, 0x10, 0x4b, 0x54, 0x10, 0x4a, 0x53, 0x10, 0x49, 0x52, 0x10, 0x48, 0x51,
+    0x0f, 0x46, 0x4f, 0x0f, 0x46, 0x4e, 0x0e, 0x45, 0x4e, 0x0e, 0x44, 0x4d, 0x0e, 0x43, 0x4c, 0x0e, 0x43, 0x4b, 0x0e, 0x42, 0x4a,
+    0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44,
+    0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d,
+    0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x31, 0x37,
+    0x0a, 0x2f, 0x35, 0x09, 0x28, 0x2d, 0x20, 0x46, 0x4c, 0x73, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x24, 0x6a, 0x74, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60,
+    0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d,
+    0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56,
+    0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51,
+    0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b,
+    0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44,
+    0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c,
+    0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33,
+    0x03, 0x2c, 0x32, 0x03, 0x2b, 0x31, 0x01, 0x27, 0x2d, 0x01, 0x26, 0x2c, 0x80, 0x9a, 0x9d, 0xff, 0xff, 0xff, 0xe1, 0xec, 0xed,
+    0x58, 0x94, 0x9d, 0x3e, 0x83, 0x8e, 0x3c, 0x82, 0x8d, 0x3c, 0x81, 0x8c, 0x3c, 0x80, 0x8b, 0x3b, 0x7f, 0x8a, 0x3b, 0x7f, 0x8a,
+    0x3a, 0x7e, 0x89, 0x39, 0x7d, 0x88, 0x38, 0x7d, 0x87, 0x37, 0x7b, 0x86, 0x36, 0x7b, 0x85, 0x34, 0x79, 0x84, 0x33, 0x78, 0x83,
+    0x32, 0x77, 0x82, 0x31, 0x76, 0x81, 0x30, 0x74, 0x7f, 0x2f, 0x73, 0x7e, 0x2e, 0x72, 0x7d, 0x2d, 0x71, 0x7c, 0x2c, 0x70, 0x7b,
+    0x2a, 0x6e, 0x79, 0x28, 0x6d, 0x77, 0x27, 0x6c, 0x77, 0x26, 0x6b, 0x75, 0x26, 0x6a, 0x75, 0x25, 0x68, 0x73, 0x24, 0x68, 0x72,
+    0x23, 0x66, 0x70, 0x21, 0x65, 0x6f, 0x21, 0x64, 0x6f, 0x1f, 0x63, 0x6d, 0x1e, 0x61, 0x6d, 0x1d, 0x60, 0x6b, 0x1c, 0x5f, 0x6a,
+    0x1b, 0x5e, 0x68, 0x1a, 0x5d, 0x68, 0x1a, 0x5c, 0x67, 0x19, 0x5a, 0x65, 0x18, 0x5a, 0x63, 0x18, 0x59, 0x63, 0x17, 0x58, 0x62,
+    0x16, 0x56, 0x60, 0x16, 0x55, 0x60, 0x15, 0x54, 0x5f, 0x15, 0x54, 0x5e, 0x15, 0x53, 0x5d, 0x14, 0x52, 0x5c, 0x13, 0x51, 0x5b,
+    0x13, 0x50, 0x5a, 0x12, 0x4e, 0x58, 0x12, 0x4e, 0x57, 0x12, 0x4d, 0x57, 0x12, 0x4c, 0x56, 0x11, 0x4c, 0x55, 0x10, 0x4b, 0x54,
+    0x10, 0x4b, 0x54, 0x10, 0x4a, 0x53, 0x10, 0x49, 0x52, 0x10, 0x48, 0x51, 0x10, 0x47, 0x50, 0x0f, 0x46, 0x4e, 0x0e, 0x45, 0x4e,
+    0x0e, 0x44, 0x4d, 0x0e, 0x43, 0x4c, 0x0e, 0x43, 0x4b, 0x0e, 0x42, 0x4a, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47,
+    0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41,
+    0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a,
+    0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2d, 0x33, 0x09, 0x29, 0x2e,
+    0x45, 0x60, 0x64, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x0c, 0x61, 0x6d, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61,
+    0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f,
+    0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58,
+    0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54,
+    0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e,
+    0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48,
+    0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41,
+    0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38,
+    0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f,
+    0x00, 0x25, 0x2a, 0x06, 0x2b, 0x2f, 0xa4, 0xb8, 0xba, 0xff, 0xff, 0xff, 0xde, 0xe9, 0xeb, 0x56, 0x92, 0x9b, 0x3f, 0x84, 0x8f,
+    0x3f, 0x83, 0x8e, 0x3e, 0x82, 0x8d, 0x3e, 0x82, 0x8d, 0x3d, 0x81, 0x8b, 0x3c, 0x80, 0x8b, 0x3c, 0x7f, 0x8a, 0x3b, 0x7f, 0x89,
+    0x3a, 0x7d, 0x88, 0x39, 0x7d, 0x87, 0x37, 0x7b, 0x85, 0x35, 0x79, 0x84, 0x34, 0x78, 0x83, 0x33, 0x78, 0x82, 0x32, 0x76, 0x81,
+    0x31, 0x74, 0x7f, 0x30, 0x74, 0x7e, 0x2f, 0x72, 0x7d, 0x2e, 0x71, 0x7c, 0x2c, 0x6f, 0x7a, 0x2a, 0x6f, 0x79, 0x29, 0x6d, 0x78,
+    0x28, 0x6d, 0x77, 0x26, 0x6a, 0x75, 0x26, 0x69, 0x74, 0x25, 0x68, 0x72, 0x24, 0x67, 0x71, 0x23, 0x66, 0x70, 0x22, 0x64, 0x70,
+    0x20, 0x64, 0x6e, 0x1f, 0x62, 0x6d, 0x1e, 0x61, 0x6c, 0x1d, 0x60, 0x6a, 0x1c, 0x5e, 0x69, 0x1b, 0x5e, 0x68, 0x1a, 0x5c, 0x67,
+    0x1a, 0x5b, 0x66, 0x18, 0x5a, 0x64, 0x18, 0x59, 0x63, 0x18, 0x59, 0x62, 0x17, 0x57, 0x61, 0x16, 0x55, 0x60, 0x16, 0x54, 0x5f,
+    0x15, 0x54, 0x5e, 0x15, 0x53, 0x5d, 0x15, 0x53, 0x5d, 0x13, 0x51, 0x5b, 0x13, 0x50, 0x5a, 0x13, 0x4f, 0x59, 0x12, 0x4e, 0x57,
+    0x12, 0x4d, 0x57, 0x12, 0x4c, 0x56, 0x12, 0x4c, 0x55, 0x10, 0x4b, 0x54, 0x10, 0x4b, 0x54, 0x10, 0x4a, 0x53, 0x10, 0x49, 0x52,
+    0x10, 0x48, 0x51, 0x10, 0x47, 0x50, 0x10, 0x47, 0x4f, 0x0e, 0x45, 0x4e, 0x0e, 0x44, 0x4d, 0x0e, 0x43, 0x4c, 0x0e, 0x43, 0x4b,
+    0x0e, 0x42, 0x4a, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45,
+    0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e,
+    0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37,
+    0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x29, 0x2e, 0x23, 0x49, 0x4f, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60,
+    0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e,
+    0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a,
+    0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56,
+    0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51,
+    0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c,
+    0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45,
+    0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d,
+    0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34,
+    0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x00, 0x22, 0x27, 0x12, 0x35, 0x3a,
+    0xcc, 0xd7, 0xd9, 0xff, 0xff, 0xff, 0xd6, 0xe5, 0xe7, 0x51, 0x8f, 0x99, 0x43, 0x86, 0x90, 0x41, 0x84, 0x8e, 0x41, 0x84, 0x8e,
+    0x40, 0x83, 0x8d, 0x3f, 0x82, 0x8c, 0x3e, 0x81, 0x8c, 0x3d, 0x80, 0x8a, 0x3c, 0x7f, 0x8a, 0x3c, 0x7e, 0x88, 0x39, 0x7c, 0x86,
+    0x38, 0x7b, 0x86, 0x37, 0x7a, 0x84, 0x36, 0x7a, 0x84, 0x34, 0x78, 0x82, 0x33, 0x76, 0x80, 0x32, 0x75, 0x80, 0x31, 0x73, 0x7e,
+    0x30, 0x73, 0x7d, 0x2e, 0x71, 0x7b, 0x2c, 0x70, 0x7a, 0x2b, 0x6e, 0x79, 0x29, 0x6d, 0x77, 0x28, 0x6c, 0x77, 0x27, 0x6a, 0x75,
+    0x26, 0x69, 0x74, 0x26, 0x68, 0x72, 0x24, 0x67, 0x71, 0x23, 0x65, 0x70, 0x21, 0x64, 0x6f, 0x20, 0x63, 0x6e, 0x1f, 0x61, 0x6d,
+    0x1e, 0x61, 0x6b, 0x1d, 0x5f, 0x69, 0x1c, 0x5e, 0x69, 0x1b, 0x5d, 0x67, 0x1a, 0x5b, 0x66, 0x19, 0x5b, 0x65, 0x18, 0x59, 0x64,
+    0x18, 0x59, 0x62, 0x18, 0x58, 0x61, 0x17, 0x56, 0x61, 0x16, 0x54, 0x5f, 0x16, 0x54, 0x5e, 0x15, 0x53, 0x5d, 0x15, 0x53, 0x5d,
+    0x14, 0x52, 0x5c, 0x13, 0x50, 0x5a, 0x13, 0x4f, 0x59, 0x13, 0x4f, 0x58, 0x12, 0x4d, 0x57, 0x12, 0x4c, 0x56, 0x12, 0x4c, 0x55,
+    0x10, 0x4b, 0x54, 0x10, 0x4b, 0x54, 0x10, 0x4a, 0x53, 0x10, 0x49, 0x52, 0x10, 0x48, 0x51, 0x10, 0x47, 0x50, 0x10, 0x47, 0x4f,
+    0x0e, 0x45, 0x4e, 0x0e, 0x44, 0x4d, 0x0e, 0x43, 0x4c, 0x0e, 0x43, 0x4b, 0x0e, 0x42, 0x4a, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48,
+    0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42,
+    0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b,
+    0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34,
+    0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62,
+    0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f,
+    0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55,
+    0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f,
+    0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49,
+    0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42,
+    0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a,
+    0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30,
+    0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x00, 0x1f, 0x23, 0x26, 0x49, 0x4e, 0xf1, 0xf5, 0xf5, 0xff, 0xff, 0xff,
+    0xc7, 0xdb, 0xde, 0x4a, 0x8a, 0x95, 0x45, 0x86, 0x90, 0x45, 0x86, 0x90, 0x44, 0x85, 0x8f, 0x42, 0x83, 0x8e, 0x41, 0x83, 0x8d,
+    0x40, 0x82, 0x8c, 0x3f, 0x81, 0x8b, 0x3d, 0x80, 0x8a, 0x3c, 0x7e, 0x88, 0x3b, 0x7d, 0x88, 0x3a, 0x7c, 0x86, 0x38, 0x7b, 0x85,
+    0x37, 0x79, 0x84, 0x36, 0x78, 0x82, 0x34, 0x77, 0x81, 0x33, 0x75, 0x80, 0x31, 0x74, 0x7e, 0x31, 0x72, 0x7d, 0x2e, 0x71, 0x7b,
+    0x2d, 0x70, 0x7a, 0x2b, 0x6e, 0x78, 0x2a, 0x6d, 0x78, 0x29, 0x6b, 0x76, 0x27, 0x6a, 0x74, 0x26, 0x69, 0x73, 0x26, 0x68, 0x72,
+    0x25, 0x66, 0x71, 0x22, 0x65, 0x6f, 0x21, 0x63, 0x6f, 0x20, 0x62, 0x6d, 0x1f, 0x61, 0x6c, 0x1e, 0x60, 0x6a, 0x1d, 0x5f, 0x69,
+    0x1c, 0x5d, 0x68, 0x1b, 0x5c, 0x66, 0x19, 0x5b, 0x65, 0x19, 0x5a, 0x65, 0x18, 0x59, 0x63, 0x18, 0x58, 0x61, 0x17, 0x56, 0x61,
+    0x17, 0x55, 0x60, 0x16, 0x54, 0x5e, 0x16, 0x53, 0x5d, 0x15, 0x53, 0x5d, 0x14, 0x52, 0x5c, 0x14, 0x51, 0x5b, 0x13, 0x4f, 0x59,
+    0x13, 0x4f, 0x58, 0x12, 0x4d, 0x57, 0x12, 0x4c, 0x56, 0x12, 0x4c, 0x55, 0x11, 0x4b, 0x54, 0x10, 0x4b, 0x54, 0x10, 0x4a, 0x53,
+    0x10, 0x49, 0x52, 0x10, 0x48, 0x51, 0x10, 0x47, 0x50, 0x10, 0x47, 0x4f, 0x0f, 0x46, 0x4f, 0x0e, 0x44, 0x4d, 0x0e, 0x43, 0x4c,
+    0x0e, 0x43, 0x4b, 0x0e, 0x42, 0x4a, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45,
+    0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f,
+    0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38,
+    0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61,
+    0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e,
+    0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b,
+    0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57,
+    0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52,
+    0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d,
+    0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46,
+    0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e,
+    0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36,
+    0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c,
+    0x02, 0x25, 0x2a, 0x00, 0x1d, 0x22, 0x4d, 0x6c, 0x71, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb1, 0xcd, 0xd1, 0x48, 0x88, 0x93,
+    0x47, 0x88, 0x92, 0x47, 0x87, 0x91, 0x46, 0x86, 0x90, 0x45, 0x85, 0x90, 0x43, 0x84, 0x8e, 0x42, 0x83, 0x8d, 0x41, 0x82, 0x8c,
+    0x3e, 0x80, 0x8a, 0x3d, 0x7f, 0x89, 0x3d, 0x7e, 0x88, 0x3b, 0x7d, 0x87, 0x3a, 0x7b, 0x85, 0x38, 0x79, 0x83, 0x37, 0x79, 0x83,
+    0x35, 0x76, 0x81, 0x34, 0x76, 0x80, 0x32, 0x74, 0x7e, 0x30, 0x72, 0x7c, 0x2f, 0x71, 0x7c, 0x2d, 0x70, 0x79, 0x2c, 0x6e, 0x79,
+    0x2a, 0x6c, 0x77, 0x29, 0x6b, 0x75, 0x28, 0x6a, 0x74, 0x26, 0x69, 0x73, 0x26, 0x67, 0x72, 0x24, 0x66, 0x70, 0x23, 0x65, 0x70,
+    0x21, 0x62, 0x6e, 0x20, 0x62, 0x6c, 0x1f, 0x60, 0x6b, 0x1e, 0x60, 0x6a, 0x1d, 0x5e, 0x68, 0x1c, 0x5c, 0x67, 0x1a, 0x5c, 0x65,
+    0x19, 0x5a, 0x65, 0x18, 0x59, 0x63, 0x18, 0x58, 0x62, 0x18, 0x57, 0x61, 0x17, 0x55, 0x60, 0x17, 0x55, 0x5f, 0x16, 0x53, 0x5d,
+    0x16, 0x53, 0x5d, 0x14, 0x52, 0x5c, 0x14, 0x51, 0x5b, 0x13, 0x4f, 0x59, 0x13, 0x4f, 0x58, 0x13, 0x4e, 0x58, 0x12, 0x4c, 0x56,
+    0x12, 0x4c, 0x55, 0x11, 0x4b, 0x54, 0x11, 0x4b, 0x54, 0x10, 0x4a, 0x53, 0x10, 0x49, 0x52, 0x10, 0x48, 0x51, 0x10, 0x47, 0x50,
+    0x10, 0x47, 0x4f, 0x0f, 0x46, 0x4f, 0x0e, 0x44, 0x4d, 0x0e, 0x43, 0x4c, 0x0e, 0x43, 0x4b, 0x0e, 0x42, 0x4a, 0x0e, 0x41, 0x49,
+    0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43,
+    0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c,
+    0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35,
+    0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60,
+    0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55,
+    0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50,
+    0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a,
+    0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43,
+    0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b,
+    0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32,
+    0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x01, 0x23, 0x28, 0x00, 0x20, 0x25,
+    0x89, 0xa0, 0xa4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x98, 0xbc, 0xc2, 0x4b, 0x8a, 0x94, 0x4a, 0x8a, 0x93, 0x48, 0x88, 0x92,
+    0x47, 0x87, 0x91, 0x47, 0x86, 0x90, 0x45, 0x84, 0x8f, 0x44, 0x84, 0x8d, 0x42, 0x82, 0x8c, 0x41, 0x81, 0x8b, 0x3f, 0x80, 0x8a,
+    0x3d, 0x7f, 0x88, 0x3d, 0x7d, 0x87, 0x3b, 0x7b, 0x85, 0x39, 0x7a, 0x84, 0x38, 0x78, 0x82, 0x36, 0x77, 0x81, 0x34, 0x75, 0x7f,
+    0x32, 0x74, 0x7e, 0x31, 0x72, 0x7d, 0x30, 0x72, 0x7b, 0x2e, 0x6f, 0x7a, 0x2c, 0x6d, 0x78, 0x2b, 0x6d, 0x76, 0x29, 0x6a, 0x74,
+    0x28, 0x6a, 0x74, 0x27, 0x68, 0x73, 0x25, 0x67, 0x71, 0x24, 0x65, 0x70, 0x23, 0x64, 0x6f, 0x21, 0x62, 0x6d, 0x20, 0x61, 0x6b,
+    0x1f, 0x60, 0x6b, 0x1e, 0x5f, 0x69, 0x1d, 0x5d, 0x67, 0x1b, 0x5c, 0x66, 0x1a, 0x5b, 0x65, 0x19, 0x5a, 0x64, 0x18, 0x58, 0x62,
+    0x18, 0x57, 0x62, 0x18, 0x56, 0x60, 0x17, 0x55, 0x5f, 0x17, 0x54, 0x5e, 0x16, 0x53, 0x5d, 0x14, 0x52, 0x5c, 0x14, 0x51, 0x5b,
+    0x14, 0x50, 0x5a, 0x13, 0x4f, 0x58, 0x13, 0x4e, 0x58, 0x13, 0x4d, 0x57, 0x12, 0x4c, 0x55, 0x11, 0x4b, 0x54, 0x11, 0x4b, 0x54,
+    0x10, 0x4a, 0x53, 0x10, 0x49, 0x52, 0x10, 0x48, 0x51, 0x10, 0x47, 0x50, 0x10, 0x47, 0x4f, 0x0f, 0x46, 0x4f, 0x0f, 0x45, 0x4e,
+    0x0e, 0x43, 0x4c, 0x0e, 0x43, 0x4b, 0x0e, 0x42, 0x4a, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46,
+    0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40,
+    0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39,
+    0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61,
+    0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e,
+    0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b,
+    0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57,
+    0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53,
+    0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d,
+    0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47,
+    0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f,
+    0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37,
+    0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e,
+    0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x00, 0x1e, 0x23, 0x0e, 0x2e, 0x33, 0xca, 0xd6, 0xd7, 0xff, 0xff, 0xff,
+    0xf9, 0xfb, 0xfb, 0x7a, 0xa9, 0xb0, 0x4e, 0x8c, 0x95, 0x4c, 0x8a, 0x94, 0x4b, 0x89, 0x93, 0x4a, 0x89, 0x92, 0x48, 0x87, 0x91,
+    0x47, 0x86, 0x90, 0x45, 0x84, 0x8e, 0x43, 0x82, 0x8d, 0x42, 0x82, 0x8b, 0x41, 0x81, 0x8b, 0x3e, 0x7e, 0x88, 0x3d, 0x7d, 0x87,
+    0x3c, 0x7c, 0x86, 0x3a, 0x7a, 0x84, 0x39, 0x79, 0x83, 0x37, 0x77, 0x81, 0x34, 0x76, 0x7f, 0x32, 0x73, 0x7e, 0x32, 0x73, 0x7c,
+    0x30, 0x71, 0x7b, 0x2e, 0x6f, 0x79, 0x2d, 0x6e, 0x78, 0x2b, 0x6c, 0x76, 0x2a, 0x6b, 0x75, 0x28, 0x69, 0x74, 0x26, 0x68, 0x72,
+    0x25, 0x66, 0x71, 0x24, 0x64, 0x70, 0x23, 0x64, 0x6e, 0x21, 0x62, 0x6c, 0x20, 0x61, 0x6b, 0x1f, 0x5f, 0x6a, 0x1e, 0x5e, 0x68,
+    0x1c, 0x5d, 0x67, 0x1b, 0x5b, 0x66, 0x1a, 0x5b, 0x64, 0x19, 0x59, 0x63, 0x19, 0x58, 0x63, 0x18, 0x56, 0x60, 0x18, 0x56, 0x60,
+    0x17, 0x54, 0x5e, 0x16, 0x53, 0x5d, 0x15, 0x52, 0x5c, 0x15, 0x51, 0x5b, 0x14, 0x50, 0x5a, 0x14, 0x50, 0x59, 0x13, 0x4e, 0x58,
+    0x13, 0x4d, 0x57, 0x12, 0x4c, 0x55, 0x11, 0x4b, 0x54, 0x11, 0x4b, 0x54, 0x11, 0x4a, 0x53, 0x10, 0x49, 0x52, 0x10, 0x48, 0x51,
+    0x10, 0x47, 0x50, 0x10, 0x47, 0x4f, 0x0f, 0x46, 0x4f, 0x0f, 0x45, 0x4e, 0x0f, 0x44, 0x4d, 0x0e, 0x43, 0x4b, 0x0e, 0x42, 0x4a,
+    0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44,
+    0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d,
+    0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36,
+    0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60,
+    0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d,
+    0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56,
+    0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51,
+    0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b,
+    0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44,
+    0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c,
+    0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33,
+    0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29,
+    0x02, 0x23, 0x27, 0x00, 0x1b, 0x1f, 0x31, 0x51, 0x56, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xe5, 0xee, 0xef, 0x64, 0x9a, 0xa2,
+    0x50, 0x8c, 0x96, 0x4f, 0x8c, 0x96, 0x4e, 0x8b, 0x94, 0x4c, 0x89, 0x93, 0x4b, 0x89, 0x92, 0x49, 0x87, 0x90, 0x47, 0x85, 0x8f,
+    0x45, 0x83, 0x8d, 0x43, 0x82, 0x8c, 0x41, 0x80, 0x8a, 0x40, 0x7f, 0x88, 0x3e, 0x7e, 0x87, 0x3d, 0x7b, 0x85, 0x3b, 0x7a, 0x84,
+    0x39, 0x78, 0x82, 0x36, 0x77, 0x80, 0x35, 0x75, 0x80, 0x33, 0x74, 0x7e, 0x32, 0x72, 0x7c, 0x31, 0x70, 0x7b, 0x2f, 0x6f, 0x79,
+    0x2d, 0x6d, 0x77, 0x2b, 0x6c, 0x76, 0x2a, 0x6a, 0x75, 0x27, 0x69, 0x73, 0x26, 0x67, 0x72, 0x25, 0x65, 0x70, 0x24, 0x64, 0x6f,
+    0x23, 0x63, 0x6d, 0x21, 0x62, 0x6c, 0x20, 0x60, 0x6a, 0x1f, 0x5e, 0x69, 0x1d, 0x5e, 0x67, 0x1c, 0x5c, 0x67, 0x1b, 0x5b, 0x65,
+    0x1a, 0x5a, 0x63, 0x19, 0x58, 0x63, 0x18, 0x56, 0x61, 0x18, 0x56, 0x60, 0x18, 0x55, 0x5f, 0x17, 0x54, 0x5e, 0x16, 0x53, 0x5d,
+    0x15, 0x51, 0x5b, 0x14, 0x50, 0x5a, 0x14, 0x50, 0x59, 0x13, 0x4e, 0x58, 0x13, 0x4d, 0x57, 0x13, 0x4d, 0x56, 0x11, 0x4b, 0x54,
+    0x11, 0x4b, 0x54, 0x11, 0x4a, 0x53, 0x11, 0x49, 0x52, 0x10, 0x48, 0x51, 0x10, 0x47, 0x50, 0x10, 0x47, 0x4f, 0x0f, 0x46, 0x4f,
+    0x0f, 0x45, 0x4e, 0x0f, 0x44, 0x4d, 0x0e, 0x43, 0x4b, 0x0e, 0x42, 0x4a, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47,
+    0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41,
+    0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a,
+    0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30,
+    0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61,
+    0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f,
+    0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58,
+    0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54,
+    0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e,
+    0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48,
+    0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41,
+    0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38,
+    0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f,
+    0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x20, 0x25, 0x00, 0x1b, 0x1f,
+    0x77, 0x90, 0x93, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc5, 0xd9, 0xdc, 0x53, 0x8f, 0x98, 0x52, 0x8e, 0x98, 0x52, 0x8e, 0x96,
+    0x50, 0x8c, 0x95, 0x4e, 0x8a, 0x94, 0x4b, 0x88, 0x92, 0x4a, 0x87, 0x91, 0x49, 0x86, 0x8f, 0x47, 0x85, 0x8e, 0x45, 0x83, 0x8c,
+    0x43, 0x81, 0x8a, 0x41, 0x7f, 0x89, 0x3f, 0x7d, 0x87, 0x3d, 0x7c, 0x86, 0x3c, 0x7a, 0x84, 0x39, 0x79, 0x82, 0x37, 0x77, 0x81,
+    0x35, 0x75, 0x7f, 0x33, 0x73, 0x7e, 0x32, 0x72, 0x7c, 0x31, 0x70, 0x7a, 0x2f, 0x6e, 0x78, 0x2d, 0x6d, 0x77, 0x2c, 0x6b, 0x76,
+    0x29, 0x6a, 0x74, 0x27, 0x68, 0x73, 0x26, 0x66, 0x71, 0x25, 0x65, 0x6f, 0x24, 0x64, 0x6e, 0x23, 0x63, 0x6d, 0x21, 0x61, 0x6b,
+    0x20, 0x5f, 0x69, 0x1e, 0x5e, 0x68, 0x1d, 0x5d, 0x67, 0x1c, 0x5c, 0x66, 0x1a, 0x5a, 0x63, 0x1a, 0x59, 0x63, 0x19, 0x57, 0x62,
+    0x18, 0x56, 0x60, 0x18, 0x55, 0x5f, 0x17, 0x54, 0x5e, 0x16, 0x53, 0x5d, 0x15, 0x51, 0x5b, 0x15, 0x50, 0x5a, 0x14, 0x50, 0x59,
+    0x14, 0x4f, 0x59, 0x13, 0x4d, 0x57, 0x13, 0x4d, 0x56, 0x12, 0x4c, 0x55, 0x11, 0x4b, 0x54, 0x11, 0x4a, 0x53, 0x11, 0x49, 0x52,
+    0x10, 0x48, 0x51, 0x10, 0x47, 0x50, 0x10, 0x47, 0x4f, 0x0f, 0x46, 0x4f, 0x0f, 0x45, 0x4e, 0x0f, 0x44, 0x4d, 0x0f, 0x44, 0x4c,
+    0x0e, 0x42, 0x4a, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45,
+    0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e,
+    0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37,
+    0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60,
+    0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e,
+    0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a,
+    0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56,
+    0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51,
+    0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c,
+    0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45,
+    0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d,
+    0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34,
+    0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a,
+    0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x00, 0x1c, 0x20, 0x0d, 0x2b, 0x30, 0xcd, 0xd7, 0xd8, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0x9b, 0xbd, 0xc3, 0x56, 0x91, 0x9a, 0x55, 0x90, 0x99, 0x53, 0x8e, 0x98, 0x52, 0x8d, 0x96, 0x4f, 0x8b, 0x94,
+    0x4d, 0x89, 0x93, 0x4b, 0x88, 0x91, 0x49, 0x86, 0x90, 0x48, 0x84, 0x8e, 0x46, 0x82, 0x8c, 0x44, 0x81, 0x8b, 0x42, 0x7f, 0x89,
+    0x40, 0x7e, 0x88, 0x3e, 0x7c, 0x86, 0x3c, 0x7b, 0x84, 0x3a, 0x79, 0x83, 0x38, 0x77, 0x81, 0x36, 0x75, 0x7f, 0x34, 0x73, 0x7d,
+    0x32, 0x72, 0x7b, 0x31, 0x70, 0x79, 0x2f, 0x6e, 0x78, 0x2d, 0x6c, 0x77, 0x2b, 0x6b, 0x75, 0x29, 0x69, 0x74, 0x27, 0x67, 0x72,
+    0x26, 0x66, 0x70, 0x25, 0x64, 0x6e, 0x24, 0x64, 0x6e, 0x22, 0x61, 0x6c, 0x21, 0x60, 0x6a, 0x1f, 0x5f, 0x68, 0x1e, 0x5d, 0x68,
+    0x1c, 0x5c, 0x66, 0x1b, 0x5a, 0x64, 0x1a, 0x59, 0x63, 0x19, 0x57, 0x62, 0x18, 0x56, 0x60, 0x18, 0x55, 0x5f, 0x18, 0x55, 0x5f,
+    0x16, 0x53, 0x5d, 0x15, 0x51, 0x5b, 0x15, 0x50, 0x5a, 0x15, 0x50, 0x59, 0x14, 0x4f, 0x59, 0x14, 0x4e, 0x58, 0x13, 0x4d, 0x56,
+    0x12, 0x4c, 0x55, 0x11, 0x4b, 0x54, 0x11, 0x4a, 0x53, 0x11, 0x49, 0x52, 0x11, 0x48, 0x51, 0x10, 0x47, 0x50, 0x10, 0x47, 0x4f,
+    0x0f, 0x46, 0x4f, 0x0f, 0x45, 0x4e, 0x0f, 0x44, 0x4d, 0x0f, 0x44, 0x4c, 0x0f, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48,
+    0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42,
+    0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b,
+    0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34,
+    0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62,
+    0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f,
+    0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55,
+    0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f,
+    0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49,
+    0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42,
+    0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a,
+    0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30,
+    0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26,
+    0x02, 0x20, 0x24, 0x00, 0x18, 0x1c, 0x3b, 0x58, 0x5e, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xf2, 0xf6, 0xf7, 0x74, 0xa4, 0xac,
+    0x58, 0x92, 0x9a, 0x57, 0x90, 0x9a, 0x55, 0x8f, 0x98, 0x53, 0x8d, 0x96, 0x50, 0x8b, 0x94, 0x4e, 0x8a, 0x93, 0x4d, 0x89, 0x92,
+    0x4a, 0x86, 0x90, 0x49, 0x84, 0x8e, 0x47, 0x83, 0x8c, 0x45, 0x81, 0x8b, 0x43, 0x80, 0x89, 0x41, 0x7e, 0x87, 0x3e, 0x7c, 0x85,
+    0x3c, 0x7a, 0x84, 0x3a, 0x79, 0x82, 0x38, 0x76, 0x81, 0x36, 0x74, 0x7f, 0x34, 0x73, 0x7c, 0x32, 0x71, 0x7a, 0x31, 0x70, 0x79,
+    0x2f, 0x6d, 0x78, 0x2c, 0x6c, 0x76, 0x2b, 0x6b, 0x75, 0x29, 0x68, 0x73, 0x27, 0x67, 0x71, 0x26, 0x65, 0x6f, 0x25, 0x64, 0x6e,
+    0x24, 0x63, 0x6d, 0x22, 0x60, 0x6b, 0x20, 0x60, 0x69, 0x1e, 0x5d, 0x68, 0x1d, 0x5d, 0x66, 0x1c, 0x5b, 0x65, 0x1b, 0x59, 0x64,
+    0x1a, 0x58, 0x62, 0x19, 0x57, 0x61, 0x19, 0x56, 0x60, 0x18, 0x55, 0x5f, 0x17, 0x54, 0x5e, 0x16, 0x52, 0x5c, 0x16, 0x51, 0x5b,
+    0x15, 0x50, 0x59, 0x14, 0x4f, 0x59, 0x14, 0x4e, 0x58, 0x13, 0x4d, 0x56, 0x12, 0x4c, 0x55, 0x12, 0x4c, 0x55, 0x11, 0x4a, 0x53,
+    0x11, 0x49, 0x52, 0x11, 0x48, 0x51, 0x10, 0x47, 0x50, 0x10, 0x47, 0x4f, 0x0f, 0x46, 0x4f, 0x0f, 0x45, 0x4e, 0x0f, 0x44, 0x4d,
+    0x0f, 0x44, 0x4c, 0x0f, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45,
+    0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f,
+    0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38,
+    0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61,
+    0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e,
+    0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b,
+    0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57,
+    0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52,
+    0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d,
+    0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46,
+    0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e,
+    0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36,
+    0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c,
+    0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x01, 0x1d, 0x21, 0x02, 0x1c, 0x21,
+    0x98, 0xab, 0xae, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xdf, 0xe2, 0x5d, 0x95, 0x9d, 0x5b, 0x93, 0x9c, 0x59, 0x92, 0x9a,
+    0x56, 0x90, 0x98, 0x55, 0x8e, 0x97, 0x52, 0x8c, 0x95, 0x50, 0x8b, 0x94, 0x4e, 0x89, 0x92, 0x4c, 0x87, 0x90, 0x49, 0x85, 0x8e,
+    0x48, 0x83, 0x8c, 0x46, 0x82, 0x8b, 0x43, 0x7f, 0x89, 0x40, 0x7e, 0x87, 0x3e, 0x7c, 0x85, 0x3d, 0x7a, 0x83, 0x3a, 0x78, 0x82,
+    0x38, 0x76, 0x80, 0x36, 0x74, 0x7e, 0x34, 0x72, 0x7c, 0x32, 0x71, 0x7a, 0x31, 0x6f, 0x79, 0x2e, 0x6d, 0x77, 0x2c, 0x6b, 0x76,
+    0x2a, 0x69, 0x74, 0x29, 0x68, 0x72, 0x27, 0x66, 0x70, 0x26, 0x65, 0x6f, 0x25, 0x63, 0x6d, 0x23, 0x61, 0x6b, 0x21, 0x60, 0x6a,
+    0x1f, 0x5e, 0x68, 0x1e, 0x5d, 0x67, 0x1d, 0x5c, 0x65, 0x1c, 0x5a, 0x65, 0x1b, 0x59, 0x63, 0x1a, 0x58, 0x61, 0x19, 0x56, 0x60,
+    0x18, 0x55, 0x5f, 0x17, 0x54, 0x5e, 0x17, 0x53, 0x5d, 0x16, 0x51, 0x5b, 0x15, 0x50, 0x59, 0x15, 0x50, 0x59, 0x14, 0x4e, 0x58,
+    0x14, 0x4e, 0x57, 0x12, 0x4c, 0x55, 0x12, 0x4c, 0x55, 0x11, 0x4a, 0x53, 0x11, 0x49, 0x52, 0x11, 0x48, 0x51, 0x11, 0x47, 0x50,
+    0x10, 0x47, 0x4f, 0x0f, 0x46, 0x4f, 0x0f, 0x45, 0x4e, 0x0f, 0x44, 0x4d, 0x0f, 0x44, 0x4c, 0x0f, 0x43, 0x4b, 0x0e, 0x41, 0x49,
+    0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43,
+    0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c,
+    0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35,
+    0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60,
+    0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55,
+    0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50,
+    0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a,
+    0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43,
+    0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b,
+    0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32,
+    0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27,
+    0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x00, 0x17, 0x1b, 0x1f, 0x3d, 0x41, 0xfa, 0xfc, 0xfc, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0x99, 0xbd, 0xc2, 0x5d, 0x95, 0x9e, 0x5c, 0x94, 0x9c, 0x59, 0x92, 0x9a, 0x57, 0x90, 0x99, 0x55, 0x8e, 0x97,
+    0x53, 0x8d, 0x95, 0x51, 0x8b, 0x94, 0x4f, 0x89, 0x92, 0x4c, 0x87, 0x90, 0x4a, 0x85, 0x8e, 0x49, 0x84, 0x8d, 0x46, 0x81, 0x8a,
+    0x43, 0x80, 0x88, 0x41, 0x7e, 0x87, 0x3e, 0x7c, 0x85, 0x3d, 0x7a, 0x83, 0x3b, 0x77, 0x81, 0x39, 0x76, 0x7f, 0x36, 0x73, 0x7d,
+    0x34, 0x72, 0x7c, 0x32, 0x70, 0x7a, 0x30, 0x6f, 0x78, 0x2e, 0x6d, 0x77, 0x2c, 0x6a, 0x75, 0x2a, 0x69, 0x73, 0x28, 0x67, 0x71,
+    0x26, 0x65, 0x70, 0x26, 0x64, 0x6e, 0x24, 0x62, 0x6c, 0x22, 0x61, 0x6a, 0x20, 0x5f, 0x69, 0x1f, 0x5e, 0x67, 0x1e, 0x5c, 0x66,
+    0x1d, 0x5b, 0x65, 0x1c, 0x59, 0x64, 0x1a, 0x58, 0x61, 0x19, 0x56, 0x60, 0x18, 0x55, 0x5f, 0x17, 0x55, 0x5e, 0x17, 0x53, 0x5d,
+    0x16, 0x51, 0x5b, 0x16, 0x51, 0x5a, 0x15, 0x50, 0x59, 0x15, 0x4f, 0x58, 0x14, 0x4e, 0x57, 0x12, 0x4c, 0x55, 0x12, 0x4c, 0x55,
+    0x12, 0x4b, 0x54, 0x11, 0x49, 0x52, 0x11, 0x48, 0x51, 0x11, 0x47, 0x50, 0x10, 0x47, 0x4f, 0x0f, 0x46, 0x4f, 0x0f, 0x45, 0x4e,
+    0x0f, 0x44, 0x4d, 0x0f, 0x44, 0x4c, 0x0f, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46,
+    0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40,
+    0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39,
+    0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61,
+    0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e,
+    0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b,
+    0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57,
+    0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53,
+    0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d,
+    0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47,
+    0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f,
+    0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37,
+    0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e,
+    0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23,
+    0x02, 0x1c, 0x21, 0x00, 0x16, 0x1a, 0x78, 0x8f, 0x92, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, 0xf1, 0xf2, 0x6f, 0xa0, 0xa8,
+    0x5f, 0x96, 0x9e, 0x5d, 0x94, 0x9c, 0x5a, 0x91, 0x9b, 0x58, 0x90, 0x99, 0x56, 0x8f, 0x98, 0x54, 0x8c, 0x95, 0x52, 0x8b, 0x93,
+    0x50, 0x89, 0x92, 0x4d, 0x87, 0x90, 0x4b, 0x85, 0x8f, 0x49, 0x83, 0x8c, 0x46, 0x82, 0x8a, 0x43, 0x7f, 0x88, 0x41, 0x7e, 0x86,
+    0x3f, 0x7b, 0x85, 0x3d, 0x79, 0x83, 0x3b, 0x77, 0x81, 0x39, 0x75, 0x7f, 0x36, 0x73, 0x7d, 0x34, 0x71, 0x7c, 0x32, 0x70, 0x7a,
+    0x30, 0x6e, 0x78, 0x2e, 0x6c, 0x76, 0x2c, 0x6a, 0x74, 0x2a, 0x68, 0x72, 0x28, 0x67, 0x71, 0x26, 0x65, 0x6f, 0x26, 0x63, 0x6d,
+    0x23, 0x62, 0x6b, 0x22, 0x60, 0x6a, 0x20, 0x5f, 0x68, 0x1f, 0x5d, 0x67, 0x25, 0x60, 0x6b, 0x30, 0x68, 0x72, 0x3b, 0x70, 0x78,
+    0x4b, 0x7b, 0x82, 0x56, 0x83, 0x8a, 0x58, 0x84, 0x8c, 0x51, 0x7f, 0x86, 0x4c, 0x79, 0x81, 0x3f, 0x70, 0x77, 0x31, 0x65, 0x6d,
+    0x26, 0x5b, 0x64, 0x18, 0x51, 0x5a, 0x13, 0x4d, 0x56, 0x12, 0x4c, 0x55, 0x12, 0x4b, 0x54, 0x11, 0x49, 0x52, 0x11, 0x48, 0x51,
+    0x11, 0x47, 0x50, 0x11, 0x47, 0x4f, 0x0f, 0x46, 0x4f, 0x0f, 0x45, 0x4e, 0x0f, 0x44, 0x4d, 0x0f, 0x44, 0x4c, 0x0f, 0x43, 0x4b,
+    0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44,
+    0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d,
+    0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36,
+    0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60,
+    0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d,
+    0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56,
+    0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51,
+    0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b,
+    0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44,
+    0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c,
+    0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33,
+    0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29,
+    0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x00, 0x17, 0x1b, 0x13, 0x2f, 0x34,
+    0xea, 0xef, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb8, 0xd1, 0xd4, 0x63, 0x98, 0xa0, 0x60, 0x96, 0x9f, 0x5e, 0x94, 0x9d,
+    0x5c, 0x93, 0x9b, 0x59, 0x91, 0x99, 0x57, 0x8f, 0x98, 0x55, 0x8d, 0x96, 0x53, 0x8b, 0x94, 0x50, 0x89, 0x91, 0x4e, 0x87, 0x90,
+    0x4b, 0x85, 0x8e, 0x49, 0x83, 0x8c, 0x46, 0x81, 0x8a, 0x44, 0x7f, 0x88, 0x41, 0x7d, 0x86, 0x3f, 0x7b, 0x84, 0x3d, 0x79, 0x82,
+    0x3b, 0x77, 0x80, 0x38, 0x75, 0x7e, 0x36, 0x73, 0x7d, 0x33, 0x71, 0x7b, 0x32, 0x6f, 0x7a, 0x2f, 0x6c, 0x77, 0x2d, 0x6b, 0x75,
+    0x2b, 0x69, 0x73, 0x29, 0x67, 0x71, 0x27, 0x65, 0x6f, 0x26, 0x64, 0x6e, 0x35, 0x6e, 0x78, 0x60, 0x8d, 0x94, 0x91, 0xb0, 0xb5,
+    0xb8, 0xcc, 0xcf, 0xd4, 0xe0, 0xe2, 0xec, 0xf1, 0xf2, 0xfd, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0xfa, 0xfa, 0xe4, 0xeb, 0xec, 0xcb, 0xd8, 0xd9, 0xab, 0xbf, 0xc3,
+    0x7f, 0x9f, 0xa4, 0x49, 0x75, 0x7c, 0x20, 0x55, 0x5d, 0x11, 0x48, 0x51, 0x11, 0x47, 0x50, 0x11, 0x47, 0x4f, 0x0f, 0x46, 0x4f,
+    0x0f, 0x45, 0x4e, 0x0f, 0x44, 0x4d, 0x0f, 0x44, 0x4c, 0x0f, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47,
+    0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41,
+    0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a,
+    0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30,
+    0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61,
+    0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f,
+    0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58,
+    0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54,
+    0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e,
+    0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48,
+    0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41,
+    0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38,
+    0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f,
+    0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24,
+    0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x00, 0x14, 0x18, 0x69, 0x81, 0x85, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xf7, 0xfa, 0xfa, 0x82, 0xad, 0xb3, 0x64, 0x99, 0xa1, 0x61, 0x96, 0x9f, 0x60, 0x95, 0x9d, 0x5d, 0x93, 0x9c, 0x5b, 0x91, 0x9a,
+    0x58, 0x8f, 0x97, 0x55, 0x8d, 0x96, 0x54, 0x8b, 0x94, 0x51, 0x89, 0x92, 0x4f, 0x87, 0x90, 0x4b, 0x85, 0x8e, 0x49, 0x83, 0x8c,
+    0x47, 0x81, 0x8a, 0x44, 0x7f, 0x88, 0x41, 0x7c, 0x86, 0x3f, 0x7b, 0x84, 0x3d, 0x78, 0x81, 0x3b, 0x77, 0x80, 0x38, 0x74, 0x7e,
+    0x35, 0x73, 0x7c, 0x33, 0x70, 0x7a, 0x31, 0x6e, 0x78, 0x2f, 0x6c, 0x76, 0x2d, 0x6a, 0x74, 0x3e, 0x77, 0x80, 0x7b, 0xa1, 0xa7,
+    0xbb, 0xce, 0xd2, 0xee, 0xf3, 0xf3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0xe9, 0xea,
+    0xa9, 0xbd, 0xc0, 0x5e, 0x83, 0x89, 0x1e, 0x51, 0x59, 0x10, 0x46, 0x4f, 0x0f, 0x45, 0x4e, 0x0f, 0x44, 0x4d, 0x0f, 0x44, 0x4c,
+    0x0f, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45,
+    0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e,
+    0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37,
+    0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60,
+    0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e,
+    0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a,
+    0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56,
+    0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51,
+    0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c,
+    0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45,
+    0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d,
+    0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34,
+    0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a,
+    0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f,
+    0x00, 0x16, 0x19, 0x11, 0x2c, 0x30, 0xe9, 0xed, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc9, 0xdc, 0xdf, 0x68, 0x9b, 0xa3,
+    0x65, 0x99, 0xa1, 0x63, 0x98, 0xa0, 0x60, 0x96, 0x9e, 0x5e, 0x93, 0x9b, 0x5b, 0x91, 0x99, 0x59, 0x8f, 0x98, 0x56, 0x8d, 0x96,
+    0x55, 0x8c, 0x94, 0x52, 0x89, 0x92, 0x4e, 0x87, 0x8f, 0x4b, 0x85, 0x8e, 0x49, 0x83, 0x8b, 0x47, 0x81, 0x8a, 0x44, 0x7e, 0x87,
+    0x41, 0x7c, 0x85, 0x3e, 0x79, 0x82, 0x3d, 0x78, 0x81, 0x3a, 0x75, 0x7f, 0x37, 0x74, 0x7d, 0x34, 0x71, 0x7b, 0x33, 0x6f, 0x79,
+    0x5d, 0x8d, 0x94, 0xad, 0xc5, 0xc9, 0xee, 0xf3, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe3, 0xe9, 0xea,
+    0x92, 0xab, 0xaf, 0x34, 0x61, 0x69, 0x0f, 0x44, 0x4d, 0x0f, 0x44, 0x4c, 0x0f, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48,
+    0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42,
+    0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b,
+    0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34,
+    0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62,
+    0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f,
+    0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55,
+    0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f,
+    0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49,
+    0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42,
+    0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a,
+    0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30,
+    0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26,
+    0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x19, 0x1d, 0x00, 0x13, 0x17, 0x6e, 0x85, 0x89,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xfd, 0xfd, 0x8c, 0xb3, 0xb9, 0x69, 0x9b, 0xa4, 0x66, 0x99, 0xa1, 0x64, 0x98, 0xa0,
+    0x61, 0x96, 0x9e, 0x5f, 0x93, 0x9b, 0x5c, 0x91, 0x9a, 0x59, 0x8f, 0x97, 0x57, 0x8e, 0x96, 0x55, 0x8b, 0x94, 0x51, 0x89, 0x91,
+    0x4e, 0x86, 0x8f, 0x4b, 0x85, 0x8d, 0x49, 0x82, 0x8b, 0x46, 0x7f, 0x89, 0x44, 0x7e, 0x87, 0x41, 0x7b, 0x84, 0x3e, 0x79, 0x82,
+    0x3c, 0x76, 0x80, 0x39, 0x75, 0x7e, 0x63, 0x92, 0x9a, 0xc0, 0xd3, 0xd6, 0xfc, 0xfd, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf8, 0xf9, 0xa5, 0xb9, 0xbc,
+    0x37, 0x63, 0x69, 0x0f, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45,
+    0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f,
+    0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38,
+    0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61,
+    0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e,
+    0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b,
+    0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57,
+    0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52,
+    0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d,
+    0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46,
+    0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e,
+    0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36,
+    0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c,
+    0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21,
+    0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x00, 0x14, 0x17, 0x16, 0x31, 0x34, 0xf2, 0xf6, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xce, 0xdf, 0xe1, 0x6c, 0x9e, 0xa6, 0x6a, 0x9c, 0xa4, 0x67, 0x9a, 0xa2, 0x64, 0x98, 0x9f, 0x61, 0x95, 0x9d, 0x60, 0x94, 0x9c,
+    0x5d, 0x91, 0x9a, 0x5a, 0x8f, 0x98, 0x57, 0x8d, 0x95, 0x54, 0x8b, 0x93, 0x51, 0x88, 0x91, 0x4e, 0x86, 0x8f, 0x4b, 0x84, 0x8d,
+    0x49, 0x81, 0x8a, 0x46, 0x7f, 0x88, 0x43, 0x7c, 0x85, 0x40, 0x7b, 0x83, 0x55, 0x88, 0x91, 0xb7, 0xcc, 0xd0, 0xfc, 0xfd, 0xfd,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0xf8, 0xf8, 0x95, 0xac, 0xaf, 0x22, 0x51, 0x58,
+    0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43,
+    0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c,
+    0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35,
+    0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60,
+    0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55,
+    0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50,
+    0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a,
+    0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43,
+    0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b,
+    0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32,
+    0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27,
+    0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1b,
+    0x00, 0x14, 0x17, 0x84, 0x98, 0x9c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfc, 0xfd, 0x8c, 0xb3, 0xb9, 0x6d, 0x9e, 0xa6,
+    0x6b, 0x9d, 0xa4, 0x68, 0x9a, 0xa2, 0x65, 0x98, 0x9f, 0x62, 0x96, 0x9e, 0x60, 0x93, 0x9b, 0x5d, 0x91, 0x9a, 0x5a, 0x8f, 0x97,
+    0x57, 0x8d, 0x95, 0x54, 0x8a, 0x93, 0x51, 0x88, 0x90, 0x4e, 0x86, 0x8f, 0x4b, 0x83, 0x8c, 0x49, 0x81, 0x8a, 0x46, 0x7e, 0x87,
+    0x8d, 0xaf, 0xb5, 0xef, 0xf4, 0xf5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0xe8, 0xe9, 0x5d, 0x7f, 0x84, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46,
+    0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40,
+    0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39,
+    0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61,
+    0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e,
+    0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b,
+    0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57,
+    0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53,
+    0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d,
+    0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47,
+    0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f,
+    0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37,
+    0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e,
+    0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23,
+    0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x00, 0x11, 0x14, 0x26, 0x41, 0x46, 0xfd, 0xfe, 0xfe,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7, 0xda, 0xdd, 0x71, 0xa1, 0xa8, 0x6e, 0x9f, 0xa6, 0x6c, 0x9c, 0xa4, 0x69, 0x9a, 0xa2,
+    0x66, 0x98, 0xa0, 0x62, 0x95, 0x9d, 0x60, 0x94, 0x9c, 0x5d, 0x91, 0x99, 0x59, 0x8f, 0x96, 0x57, 0x8c, 0x95, 0x54, 0x8a, 0x92,
+    0x50, 0x87, 0x90, 0x4d, 0x84, 0x8d, 0x5b, 0x8d, 0x95, 0xc3, 0xd5, 0xd8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9f, 0xb3, 0xb6, 0x1a, 0x4a, 0x50, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44,
+    0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d,
+    0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36,
+    0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60,
+    0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d,
+    0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56,
+    0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51,
+    0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b,
+    0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44,
+    0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c,
+    0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33,
+    0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29,
+    0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e,
+    0x02, 0x18, 0x1c, 0x00, 0x15, 0x19, 0x04, 0x18, 0x1b, 0xb6, 0xc3, 0xc4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0xf8, 0xf9,
+    0x85, 0xad, 0xb4, 0x72, 0xa1, 0xa9, 0x6f, 0x9f, 0xa6, 0x6c, 0x9c, 0xa4, 0x69, 0x9a, 0xa2, 0x66, 0x97, 0x9f, 0x63, 0x96, 0x9e,
+    0x60, 0x92, 0x9b, 0x5c, 0x91, 0x98, 0x59, 0x8e, 0x96, 0x56, 0x8b, 0x93, 0x53, 0x89, 0x92, 0x74, 0x9f, 0xa6, 0xe4, 0xec, 0xed,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0xfb, 0xfb, 0xeb, 0xf0, 0xf1, 0xd6, 0xe1, 0xe2, 0xc4, 0xd4, 0xd6, 0xba, 0xcc, 0xcf,
+    0xb8, 0xcb, 0xce, 0xc0, 0xd0, 0xd3, 0xce, 0xdb, 0xdd, 0xe6, 0xec, 0xed, 0xf5, 0xf7, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xcf, 0xd9, 0xda, 0x34, 0x5d, 0x63, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41,
+    0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a,
+    0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30,
+    0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61,
+    0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f,
+    0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58,
+    0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54,
+    0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e,
+    0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48,
+    0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41,
+    0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38,
+    0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f,
+    0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24,
+    0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x00, 0x0f, 0x12,
+    0x4b, 0x65, 0x69, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, 0xcf, 0xd3, 0x76, 0xa4, 0xab, 0x72, 0xa1, 0xa8,
+    0x6f, 0x9e, 0xa6, 0x6c, 0x9c, 0xa4, 0x69, 0x99, 0xa1, 0x66, 0x97, 0x9f, 0x63, 0x95, 0x9d, 0x5f, 0x92, 0x9a, 0x5c, 0x90, 0x98,
+    0x58, 0x8d, 0x95, 0x88, 0xae, 0xb3, 0xf3, 0xf7, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfc, 0xfc, 0xd5, 0xe1, 0xe3, 0x9d, 0xb9, 0xbd, 0x70, 0x97, 0x9d, 0x4a, 0x7b, 0x83,
+    0x2d, 0x65, 0x6f, 0x24, 0x5f, 0x67, 0x1f, 0x5a, 0x64, 0x1d, 0x59, 0x62, 0x1b, 0x56, 0x60, 0x1a, 0x55, 0x5e, 0x1c, 0x56, 0x5f,
+    0x20, 0x58, 0x62, 0x37, 0x69, 0x71, 0x5c, 0x84, 0x8a, 0x89, 0xa5, 0xaa, 0xc2, 0xd1, 0xd4, 0xf5, 0xf7, 0xf8, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xec, 0xed, 0x4a, 0x6e, 0x74,
+    0x11, 0x3f, 0x47, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e,
+    0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37,
+    0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60,
+    0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e,
+    0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a,
+    0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56,
+    0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51,
+    0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c,
+    0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45,
+    0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d,
+    0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34,
+    0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a,
+    0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f,
+    0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x00, 0x11, 0x14, 0x10, 0x28, 0x2c, 0xeb, 0xee, 0xef, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xe6, 0xee, 0xef, 0x7d, 0xa9, 0xb0, 0x76, 0xa3, 0xaa, 0x73, 0xa1, 0xa8, 0x6f, 0x9e, 0xa6, 0x6c, 0x9c, 0xa3,
+    0x6a, 0x9a, 0xa2, 0x66, 0x97, 0x9f, 0x62, 0x94, 0x9c, 0x5f, 0x92, 0x9a, 0x94, 0xb6, 0xbb, 0xfb, 0xfc, 0xfd, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe2, 0xea, 0xec, 0x99, 0xb6, 0xba, 0x53, 0x83, 0x8b,
+    0x2c, 0x67, 0x70, 0x28, 0x64, 0x6d, 0x26, 0x61, 0x6b, 0x25, 0x5f, 0x69, 0x24, 0x5f, 0x68, 0x21, 0x5c, 0x65, 0x20, 0x5b, 0x64,
+    0x1d, 0x59, 0x62, 0x1c, 0x57, 0x61, 0x1b, 0x55, 0x5f, 0x19, 0x54, 0x5d, 0x18, 0x52, 0x5c, 0x17, 0x51, 0x5a, 0x17, 0x50, 0x59,
+    0x16, 0x4f, 0x58, 0x15, 0x4e, 0x57, 0x32, 0x64, 0x6b, 0x7a, 0x99, 0x9e, 0xd0, 0xdb, 0xdd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xee, 0xf1, 0xf2, 0x8d, 0xa3, 0xa7, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42,
+    0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b,
+    0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34,
+    0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62,
+    0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f,
+    0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55,
+    0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f,
+    0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49,
+    0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42,
+    0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a,
+    0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30,
+    0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26,
+    0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a,
+    0x01, 0x14, 0x17, 0x00, 0x12, 0x15, 0x91, 0xa4, 0xa7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9f, 0xc0, 0xc5,
+    0x79, 0xa6, 0xad, 0x76, 0xa3, 0xaa, 0x73, 0xa1, 0xa8, 0x6f, 0x9e, 0xa5, 0x6c, 0x9b, 0xa3, 0x68, 0x98, 0xa0, 0x64, 0x96, 0x9d,
+    0x98, 0xb9, 0xbe, 0xfc, 0xfd, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdd, 0xe7, 0xe8,
+    0x82, 0xa6, 0xac, 0x3d, 0x73, 0x7c, 0x2f, 0x6a, 0x73, 0x2d, 0x68, 0x72, 0x2b, 0x67, 0x70, 0x29, 0x65, 0x6e, 0x26, 0x62, 0x6c,
+    0x25, 0x5f, 0x69, 0x24, 0x5f, 0x68, 0x22, 0x5c, 0x66, 0x20, 0x5b, 0x64, 0x1e, 0x59, 0x63, 0x1d, 0x58, 0x61, 0x1b, 0x55, 0x5f,
+    0x1a, 0x55, 0x5d, 0x19, 0x53, 0x5d, 0x18, 0x51, 0x5b, 0x17, 0x51, 0x59, 0x16, 0x4f, 0x58, 0x15, 0x4e, 0x57, 0x14, 0x4d, 0x55,
+    0x14, 0x4c, 0x54, 0x17, 0x4d, 0x56, 0x59, 0x7f, 0x85, 0xc5, 0xd3, 0xd4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xb0, 0xc0, 0xc2, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f,
+    0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38,
+    0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61,
+    0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e,
+    0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b,
+    0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57,
+    0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52,
+    0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d,
+    0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46,
+    0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e,
+    0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36,
+    0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c,
+    0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21,
+    0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x00, 0x0e, 0x10, 0x3a, 0x54, 0x59,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcd, 0xde, 0xe1, 0x7c, 0xa8, 0xae, 0x79, 0xa5, 0xac, 0x76, 0xa3, 0xaa,
+    0x72, 0xa0, 0xa7, 0x6e, 0x9d, 0xa4, 0x6c, 0x9b, 0xa2, 0x92, 0xb5, 0xba, 0xfa, 0xfc, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xee, 0xf3, 0xf4, 0x91, 0xb1, 0xb6, 0x41, 0x78, 0x81, 0x36, 0x70, 0x79, 0x33, 0x6d, 0x76, 0x31, 0x6c, 0x74,
+    0x2e, 0x69, 0x72, 0x2c, 0x67, 0x70, 0x29, 0x65, 0x6e, 0x27, 0x62, 0x6c, 0x26, 0x60, 0x6a, 0x24, 0x5f, 0x68, 0x22, 0x5c, 0x66,
+    0x21, 0x5c, 0x65, 0x1e, 0x59, 0x63, 0x1d, 0x58, 0x61, 0x1b, 0x55, 0x5f, 0x1a, 0x55, 0x5d, 0x19, 0x53, 0x5d, 0x18, 0x51, 0x5b,
+    0x17, 0x51, 0x59, 0x16, 0x4f, 0x58, 0x15, 0x4e, 0x57, 0x14, 0x4d, 0x55, 0x14, 0x4c, 0x54, 0x13, 0x4a, 0x53, 0x13, 0x49, 0x52,
+    0x14, 0x49, 0x51, 0x63, 0x86, 0x8c, 0xde, 0xe5, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xac, 0xbc, 0xbf, 0x0d, 0x3b, 0x43,
+    0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c,
+    0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35,
+    0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60,
+    0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55,
+    0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50,
+    0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a,
+    0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43,
+    0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b,
+    0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32,
+    0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27,
+    0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c,
+    0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x00, 0x11, 0x12, 0x0e, 0x25, 0x28, 0xe6, 0xec, 0xec, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xf0, 0xf5, 0xf6, 0x8a, 0xb1, 0xb7, 0x7c, 0xa7, 0xae, 0x78, 0xa5, 0xab, 0x75, 0xa1, 0xa9, 0x72, 0xa0, 0xa7, 0x86, 0xad, 0xb3,
+    0xf2, 0xf6, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc3, 0xd5, 0xd8, 0x57, 0x89, 0x91, 0x3e, 0x76, 0x7f,
+    0x3b, 0x74, 0x7d, 0x38, 0x71, 0x7a, 0x35, 0x6e, 0x78, 0x32, 0x6c, 0x75, 0x2f, 0x69, 0x73, 0x2d, 0x68, 0x71, 0x2a, 0x65, 0x6e,
+    0x28, 0x63, 0x6d, 0x26, 0x61, 0x6b, 0x25, 0x5f, 0x69, 0x23, 0x5d, 0x66, 0x22, 0x5c, 0x66, 0x1f, 0x5a, 0x63, 0x1e, 0x58, 0x62,
+    0x1c, 0x56, 0x60, 0x1b, 0x55, 0x5e, 0x19, 0x53, 0x5d, 0x18, 0x51, 0x5b, 0x17, 0x51, 0x59, 0x16, 0x4f, 0x58, 0x15, 0x4e, 0x57,
+    0x15, 0x4d, 0x56, 0x14, 0x4c, 0x54, 0x13, 0x4a, 0x53, 0x13, 0x49, 0x52, 0x12, 0x48, 0x50, 0x11, 0x47, 0x50, 0x22, 0x53, 0x5b,
+    0xa0, 0xb5, 0xb8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xac, 0xbc, 0xbf, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40,
+    0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39,
+    0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61,
+    0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e,
+    0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b,
+    0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57,
+    0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53,
+    0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d,
+    0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47,
+    0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f,
+    0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37,
+    0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e,
+    0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23,
+    0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x01, 0x13, 0x16,
+    0x00, 0x11, 0x14, 0x9b, 0xac, 0xae, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa9, 0xc5, 0xca, 0x7f, 0xa9, 0xaf,
+    0x7c, 0xa7, 0xae, 0x78, 0xa4, 0xab, 0x7e, 0xa7, 0xaf, 0xe1, 0xea, 0xec, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfc, 0xfc,
+    0x98, 0xb7, 0xbc, 0x44, 0x7b, 0x85, 0x42, 0x7a, 0x83, 0x3f, 0x77, 0x80, 0x3c, 0x75, 0x7e, 0x39, 0x72, 0x7b, 0x36, 0x6f, 0x78,
+    0x33, 0x6d, 0x76, 0x31, 0x6b, 0x74, 0x2e, 0x69, 0x72, 0x2b, 0x66, 0x6f, 0x29, 0x64, 0x6e, 0x27, 0x61, 0x6b, 0x26, 0x60, 0x69,
+    0x24, 0x5e, 0x67, 0x22, 0x5c, 0x66, 0x1f, 0x5a, 0x63, 0x1e, 0x58, 0x62, 0x1d, 0x57, 0x60, 0x1b, 0x55, 0x5e, 0x1a, 0x54, 0x5d,
+    0x19, 0x52, 0x5c, 0x18, 0x51, 0x5a, 0x17, 0x50, 0x58, 0x16, 0x4f, 0x58, 0x15, 0x4d, 0x56, 0x14, 0x4c, 0x54, 0x14, 0x4b, 0x53,
+    0x13, 0x49, 0x52, 0x12, 0x48, 0x50, 0x11, 0x47, 0x50, 0x10, 0x45, 0x4e, 0x10, 0x44, 0x4d, 0x67, 0x88, 0x8d, 0xf2, 0xf5, 0xf5,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xac, 0xbc, 0xbf,
+    0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d,
+    0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36,
+    0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60,
+    0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d,
+    0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56,
+    0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51,
+    0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b,
+    0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44,
+    0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c,
+    0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33,
+    0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29,
+    0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e,
+    0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x00, 0x0d, 0x0f, 0x47, 0x61, 0x65, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0xe0, 0xe2, 0x83, 0xab, 0xb2, 0x7f, 0xa9, 0xaf, 0x7b, 0xa6, 0xad, 0xcb, 0xdb, 0xde,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xf5, 0xf6, 0x7d, 0xa5, 0xab, 0x4b, 0x81, 0x8a, 0x46, 0x7d, 0x86, 0x43, 0x7b, 0x83,
+    0x40, 0x78, 0x81, 0x3e, 0x76, 0x7f, 0x3b, 0x73, 0x7c, 0x38, 0x70, 0x7a, 0x34, 0x6e, 0x77, 0x32, 0x6b, 0x75, 0x2f, 0x69, 0x72,
+    0x2c, 0x67, 0x6f, 0x2a, 0x64, 0x6e, 0x28, 0x62, 0x6c, 0x26, 0x60, 0x69, 0x24, 0x5e, 0x67, 0x23, 0x5d, 0x66, 0x20, 0x5b, 0x64,
+    0x1e, 0x58, 0x62, 0x1d, 0x57, 0x60, 0x1c, 0x56, 0x5f, 0x1a, 0x54, 0x5d, 0x19, 0x52, 0x5c, 0x18, 0x51, 0x5a, 0x16, 0x4f, 0x58,
+    0x16, 0x4f, 0x58, 0x15, 0x4d, 0x56, 0x14, 0x4c, 0x54, 0x14, 0x4b, 0x53, 0x13, 0x49, 0x52, 0x13, 0x49, 0x51, 0x11, 0x47, 0x50,
+    0x11, 0x46, 0x4f, 0x10, 0x44, 0x4d, 0x10, 0x44, 0x4c, 0x45, 0x6d, 0x73, 0xe4, 0xe9, 0xea, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xac, 0xbc, 0xbf, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41,
+    0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a,
+    0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30,
+    0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61,
+    0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f,
+    0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58,
+    0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54,
+    0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e,
+    0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48,
+    0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41,
+    0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38,
+    0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f,
+    0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24,
+    0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18,
+    0x02, 0x13, 0x16, 0x00, 0x0d, 0x10, 0x1a, 0x32, 0x36, 0xfb, 0xfd, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xec, 0xf3, 0xf4,
+    0x8c, 0xb2, 0xb7, 0x82, 0xab, 0xb1, 0xac, 0xc7, 0xcb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xf2, 0xf3, 0x76, 0x9f, 0xa6,
+    0x4e, 0x84, 0x8c, 0x4c, 0x81, 0x8a, 0x48, 0x7e, 0x87, 0x45, 0x7c, 0x85, 0x42, 0x79, 0x82, 0x3f, 0x77, 0x80, 0x3c, 0x74, 0x7d,
+    0x39, 0x71, 0x7a, 0x35, 0x6f, 0x77, 0x33, 0x6c, 0x76, 0x30, 0x6a, 0x73, 0x2e, 0x68, 0x71, 0x2b, 0x65, 0x6f, 0x29, 0x63, 0x6d,
+    0x27, 0x61, 0x6a, 0x25, 0x5e, 0x68, 0x23, 0x5d, 0x66, 0x20, 0x5b, 0x64, 0x1f, 0x59, 0x62, 0x1e, 0x57, 0x61, 0x1c, 0x56, 0x5f,
+    0x1b, 0x54, 0x5e, 0x19, 0x52, 0x5c, 0x18, 0x51, 0x5a, 0x17, 0x50, 0x58, 0x16, 0x4f, 0x58, 0x15, 0x4d, 0x56, 0x15, 0x4c, 0x55,
+    0x14, 0x4b, 0x53, 0x13, 0x49, 0x52, 0x13, 0x49, 0x51, 0x11, 0x47, 0x50, 0x11, 0x46, 0x4f, 0x10, 0x44, 0x4d, 0x10, 0x44, 0x4c,
+    0x10, 0x43, 0x4b, 0x38, 0x62, 0x68, 0xdf, 0xe6, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xac, 0xbc, 0xbf, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e,
+    0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37,
+    0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60,
+    0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e,
+    0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a,
+    0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56,
+    0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51,
+    0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c,
+    0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45,
+    0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d,
+    0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34,
+    0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a,
+    0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f,
+    0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x00, 0x11, 0x13, 0x04, 0x16, 0x19,
+    0xcb, 0xd4, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9f, 0xbe, 0xc3, 0x8d, 0xb3, 0xb9, 0xf1, 0xf6, 0xf6,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xef, 0xf4, 0xf5, 0x79, 0xa2, 0xa8, 0x55, 0x88, 0x91, 0x50, 0x85, 0x8d, 0x4d, 0x82, 0x8b, 0x4a, 0x7f, 0x88,
+    0x46, 0x7d, 0x85, 0x43, 0x7a, 0x83, 0x40, 0x78, 0x81, 0x3d, 0x74, 0x7e, 0x3a, 0x72, 0x7b, 0x36, 0x70, 0x78, 0x34, 0x6d, 0x76,
+    0x31, 0x6b, 0x73, 0x2e, 0x68, 0x71, 0x2c, 0x66, 0x6f, 0x2a, 0x63, 0x6d, 0x28, 0x62, 0x6b, 0x26, 0x5f, 0x68, 0x24, 0x5e, 0x67,
+    0x22, 0x5c, 0x65, 0x1f, 0x59, 0x62, 0x1e, 0x57, 0x61, 0x1d, 0x57, 0x5f, 0x1b, 0x54, 0x5e, 0x1a, 0x53, 0x5c, 0x19, 0x52, 0x5b,
+    0x17, 0x50, 0x59, 0x17, 0x50, 0x58, 0x16, 0x4e, 0x57, 0x15, 0x4c, 0x55, 0x14, 0x4b, 0x53, 0x13, 0x49, 0x52, 0x13, 0x49, 0x51,
+    0x11, 0x47, 0x50, 0x11, 0x46, 0x4f, 0x10, 0x44, 0x4d, 0x10, 0x44, 0x4c, 0x10, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x3a, 0x63, 0x6a,
+    0xe7, 0xec, 0xed, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xac, 0xbc, 0xbf, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42,
+    0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b,
+    0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34,
+    0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62,
+    0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f,
+    0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55,
+    0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f,
+    0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49,
+    0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42,
+    0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a,
+    0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30,
+    0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26,
+    0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a,
+    0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x00, 0x0d, 0x0f, 0x80, 0x94, 0x97, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xbe, 0xd3, 0xd7, 0xc7, 0xda, 0xdc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xfa, 0xfb, 0x86, 0xab, 0xb1, 0x5a, 0x8d, 0x94,
+    0x57, 0x89, 0x92, 0x52, 0x87, 0x8f, 0x4e, 0x83, 0x8c, 0x4b, 0x80, 0x89, 0x48, 0x7e, 0x86, 0x44, 0x7b, 0x83, 0x41, 0x79, 0x81,
+    0x3f, 0x76, 0x7f, 0x3c, 0x73, 0x7c, 0x37, 0x70, 0x79, 0x34, 0x6d, 0x77, 0x32, 0x6b, 0x74, 0x2f, 0x69, 0x71, 0x2d, 0x66, 0x70,
+    0x2a, 0x63, 0x6d, 0x28, 0x62, 0x6b, 0x26, 0x5f, 0x68, 0x24, 0x5e, 0x67, 0x22, 0x5c, 0x65, 0x20, 0x5a, 0x63, 0x1e, 0x57, 0x61,
+    0x1d, 0x57, 0x5f, 0x1c, 0x55, 0x5f, 0x1a, 0x53, 0x5c, 0x19, 0x52, 0x5b, 0x17, 0x50, 0x59, 0x17, 0x50, 0x58, 0x16, 0x4e, 0x57,
+    0x15, 0x4c, 0x55, 0x14, 0x4b, 0x53, 0x14, 0x4a, 0x52, 0x13, 0x49, 0x51, 0x11, 0x47, 0x50, 0x11, 0x46, 0x4f, 0x10, 0x44, 0x4d,
+    0x10, 0x44, 0x4c, 0x10, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x4e, 0x72, 0x78, 0xf6, 0xf8, 0xf8, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xac, 0xbc, 0xbf, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f,
+    0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38,
+    0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61,
+    0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e,
+    0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b,
+    0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57,
+    0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52,
+    0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d,
+    0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46,
+    0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e,
+    0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36,
+    0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c,
+    0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21,
+    0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14,
+    0x00, 0x0b, 0x0d, 0x41, 0x5a, 0x5e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xf6, 0xf6, 0xf6, 0xf9, 0xf9,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xa0, 0xbd, 0xc1, 0x60, 0x90, 0x98, 0x5c, 0x8e, 0x95, 0x58, 0x8b, 0x93, 0x54, 0x88, 0x90, 0x50, 0x85, 0x8d,
+    0x4d, 0x81, 0x8a, 0x49, 0x7f, 0x87, 0x46, 0x7c, 0x84, 0x42, 0x79, 0x82, 0x40, 0x76, 0x7f, 0x3d, 0x74, 0x7d, 0x38, 0x71, 0x79,
+    0x35, 0x6e, 0x77, 0x33, 0x6c, 0x75, 0x30, 0x69, 0x72, 0x2d, 0x66, 0x70, 0x2b, 0x64, 0x6e, 0x29, 0x63, 0x6c, 0x26, 0x60, 0x69,
+    0x25, 0x5e, 0x68, 0x23, 0x5d, 0x66, 0x20, 0x5a, 0x63, 0x1f, 0x58, 0x62, 0x1e, 0x57, 0x60, 0x1c, 0x55, 0x5f, 0x1a, 0x53, 0x5c,
+    0x19, 0x52, 0x5b, 0x17, 0x50, 0x59, 0x17, 0x50, 0x58, 0x16, 0x4e, 0x57, 0x15, 0x4c, 0x55, 0x14, 0x4b, 0x53, 0x14, 0x4a, 0x52,
+    0x13, 0x49, 0x51, 0x12, 0x48, 0x51, 0x11, 0x46, 0x4f, 0x11, 0x45, 0x4e, 0x10, 0x44, 0x4c, 0x0f, 0x43, 0x4b, 0x0e, 0x41, 0x49,
+    0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x75, 0x92, 0x96, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xac, 0xbc, 0xbf, 0x0d, 0x3b, 0x43,
+    0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c,
+    0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35,
+    0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60,
+    0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55,
+    0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50,
+    0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a,
+    0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43,
+    0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b,
+    0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32,
+    0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27,
+    0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c,
+    0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x00, 0x0b, 0x0d, 0x1f, 0x37, 0x3a, 0xfd, 0xfe, 0xfe,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7, 0xd8, 0xdb, 0x66, 0x96, 0x9d, 0x62, 0x92, 0x99,
+    0x5e, 0x8f, 0x97, 0x5a, 0x8c, 0x94, 0x56, 0x89, 0x91, 0x52, 0x86, 0x8f, 0x4e, 0x83, 0x8c, 0x4b, 0x80, 0x88, 0x47, 0x7d, 0x85,
+    0x43, 0x7a, 0x83, 0x40, 0x77, 0x80, 0x3e, 0x74, 0x7d, 0x39, 0x72, 0x7a, 0x36, 0x6f, 0x78, 0x34, 0x6d, 0x75, 0x31, 0x6a, 0x73,
+    0x2e, 0x67, 0x71, 0x2c, 0x65, 0x6f, 0x29, 0x63, 0x6c, 0x27, 0x60, 0x6a, 0x26, 0x5f, 0x68, 0x24, 0x5d, 0x67, 0x22, 0x5b, 0x64,
+    0x20, 0x59, 0x62, 0x1e, 0x57, 0x60, 0x1c, 0x55, 0x5f, 0x1b, 0x53, 0x5d, 0x19, 0x52, 0x5b, 0x17, 0x50, 0x59, 0x17, 0x50, 0x58,
+    0x16, 0x4e, 0x57, 0x15, 0x4c, 0x55, 0x15, 0x4b, 0x54, 0x14, 0x4a, 0x52, 0x13, 0x49, 0x51, 0x12, 0x48, 0x51, 0x11, 0x46, 0x4f,
+    0x11, 0x45, 0x4e, 0x10, 0x44, 0x4c, 0x0f, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46,
+    0xb4, 0xc3, 0xc5, 0xff, 0xff, 0xff, 0xae, 0xbe, 0xc1, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40,
+    0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39,
+    0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61,
+    0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e,
+    0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b,
+    0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57,
+    0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53,
+    0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d,
+    0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47,
+    0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f,
+    0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37,
+    0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e,
+    0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23,
+    0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16,
+    0x01, 0x12, 0x14, 0x00, 0x0e, 0x10, 0x0a, 0x1c, 0x1f, 0xdb, 0xe1, 0xe2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xf0, 0xf5, 0xf6, 0x7b, 0xa3, 0xab, 0x68, 0x97, 0x9e, 0x64, 0x93, 0x9a, 0x60, 0x90, 0x98, 0x5b, 0x8c, 0x95, 0x57, 0x8a, 0x92,
+    0x53, 0x87, 0x8f, 0x4f, 0x83, 0x8c, 0x4c, 0x81, 0x89, 0x48, 0x7d, 0x86, 0x44, 0x7b, 0x83, 0x41, 0x78, 0x81, 0x3f, 0x75, 0x7e,
+    0x3a, 0x72, 0x7b, 0x37, 0x6f, 0x79, 0x34, 0x6d, 0x76, 0x32, 0x6b, 0x73, 0x2f, 0x68, 0x71, 0x2c, 0x65, 0x6f, 0x2a, 0x63, 0x6c,
+    0x28, 0x61, 0x6a, 0x26, 0x5f, 0x68, 0x24, 0x5d, 0x67, 0x22, 0x5b, 0x64, 0x20, 0x59, 0x62, 0x1e, 0x57, 0x60, 0x1d, 0x56, 0x5f,
+    0x1b, 0x53, 0x5d, 0x1a, 0x53, 0x5b, 0x18, 0x51, 0x5a, 0x17, 0x50, 0x59, 0x17, 0x4f, 0x57, 0x16, 0x4d, 0x56, 0x15, 0x4b, 0x54,
+    0x14, 0x4a, 0x52, 0x13, 0x49, 0x51, 0x12, 0x48, 0x51, 0x11, 0x46, 0x4f, 0x11, 0x45, 0x4e, 0x10, 0x44, 0x4c, 0x0f, 0x43, 0x4b,
+    0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x32, 0x5c, 0x61, 0xee, 0xf1, 0xf2, 0xb8, 0xc6, 0xc8,
+    0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d,
+    0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36,
+    0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60,
+    0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d,
+    0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56,
+    0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51,
+    0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b,
+    0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44,
+    0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c,
+    0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33,
+    0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29,
+    0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e,
+    0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x01, 0x10, 0x12, 0x01, 0x0e, 0x11,
+    0xb5, 0xc1, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xae, 0xc8, 0xcc, 0x6e, 0x9b, 0xa2, 0x69, 0x97, 0x9e,
+    0x65, 0x94, 0x9b, 0x61, 0x91, 0x98, 0x5d, 0x8e, 0x96, 0x59, 0x8b, 0x93, 0x55, 0x88, 0x90, 0x50, 0x84, 0x8d, 0x4d, 0x81, 0x8a,
+    0x49, 0x7e, 0x86, 0x46, 0x7c, 0x84, 0x42, 0x78, 0x81, 0x40, 0x76, 0x7f, 0x3c, 0x74, 0x7c, 0x38, 0x70, 0x79, 0x35, 0x6e, 0x77,
+    0x33, 0x6b, 0x74, 0x30, 0x68, 0x72, 0x2e, 0x66, 0x70, 0x2b, 0x64, 0x6d, 0x28, 0x61, 0x6a, 0x26, 0x60, 0x69, 0x25, 0x5e, 0x67,
+    0x23, 0x5c, 0x65, 0x21, 0x5a, 0x63, 0x1f, 0x58, 0x61, 0x1d, 0x56, 0x5f, 0x1b, 0x53, 0x5d, 0x1a, 0x53, 0x5b, 0x18, 0x51, 0x5a,
+    0x17, 0x50, 0x59, 0x17, 0x4f, 0x57, 0x16, 0x4d, 0x56, 0x15, 0x4b, 0x54, 0x14, 0x4a, 0x52, 0x13, 0x49, 0x51, 0x12, 0x48, 0x51,
+    0x11, 0x46, 0x4f, 0x11, 0x45, 0x4e, 0x10, 0x44, 0x4c, 0x0f, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47,
+    0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x85, 0x9d, 0xa1, 0x98, 0xac, 0xaf, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41,
+    0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a,
+    0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30,
+    0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61,
+    0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f,
+    0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58,
+    0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54,
+    0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e,
+    0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48,
+    0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41,
+    0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38,
+    0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f,
+    0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24,
+    0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18,
+    0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x01, 0x10, 0x12, 0x00, 0x0c, 0x0e, 0x79, 0x8e, 0x91, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xe9, 0xf0, 0xf1, 0x7a, 0xa4, 0xaa, 0x70, 0x9c, 0xa3, 0x6b, 0x99, 0xa0, 0x66, 0x95, 0x9c, 0x63, 0x92, 0x9a, 0x5f, 0x8f, 0x97,
+    0x5a, 0x8c, 0x94, 0x56, 0x89, 0x91, 0x52, 0x85, 0x8e, 0x4e, 0x83, 0x8b, 0x4b, 0x7f, 0x88, 0x47, 0x7d, 0x85, 0x43, 0x79, 0x82,
+    0x40, 0x76, 0x7f, 0x3d, 0x74, 0x7c, 0x39, 0x71, 0x7a, 0x36, 0x6f, 0x77, 0x34, 0x6c, 0x75, 0x31, 0x69, 0x73, 0x2e, 0x66, 0x70,
+    0x2c, 0x65, 0x6e, 0x29, 0x62, 0x6b, 0x26, 0x60, 0x69, 0x25, 0x5e, 0x67, 0x23, 0x5c, 0x65, 0x21, 0x5a, 0x63, 0x1f, 0x58, 0x61,
+    0x1d, 0x56, 0x5f, 0x1c, 0x54, 0x5e, 0x1a, 0x53, 0x5b, 0x18, 0x51, 0x5a, 0x17, 0x50, 0x59, 0x17, 0x4f, 0x57, 0x16, 0x4d, 0x56,
+    0x15, 0x4b, 0x54, 0x14, 0x4a, 0x52, 0x14, 0x4a, 0x51, 0x12, 0x48, 0x51, 0x11, 0x46, 0x4f, 0x11, 0x45, 0x4e, 0x10, 0x44, 0x4c,
+    0x0f, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x23, 0x4e, 0x56,
+    0x36, 0x5d, 0x64, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e,
+    0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37,
+    0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60,
+    0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e,
+    0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a,
+    0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56,
+    0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51,
+    0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c,
+    0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45,
+    0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d,
+    0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34,
+    0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a,
+    0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f,
+    0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x01, 0x10, 0x13,
+    0x00, 0x0a, 0x0c, 0x4a, 0x63, 0x67, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb2, 0xca, 0xce, 0x75, 0xa0, 0xa7, 0x70, 0x9d, 0xa4,
+    0x6d, 0x9a, 0xa1, 0x68, 0x96, 0x9d, 0x64, 0x94, 0x9b, 0x60, 0x90, 0x98, 0x5b, 0x8d, 0x95, 0x57, 0x89, 0x92, 0x53, 0x86, 0x8f,
+    0x4f, 0x83, 0x8b, 0x4c, 0x80, 0x88, 0x48, 0x7d, 0x86, 0x45, 0x7a, 0x83, 0x40, 0x76, 0x7f, 0x3d, 0x74, 0x7c, 0x3a, 0x72, 0x7b,
+    0x37, 0x6f, 0x78, 0x34, 0x6c, 0x75, 0x31, 0x69, 0x73, 0x2f, 0x67, 0x70, 0x2c, 0x65, 0x6e, 0x29, 0x62, 0x6b, 0x28, 0x61, 0x6a,
+    0x25, 0x5e, 0x67, 0x22, 0x5b, 0x64, 0x21, 0x5a, 0x63, 0x20, 0x59, 0x61, 0x1e, 0x57, 0x60, 0x1c, 0x54, 0x5e, 0x1b, 0x53, 0x5c,
+    0x18, 0x51, 0x5a, 0x17, 0x50, 0x59, 0x17, 0x4f, 0x57, 0x16, 0x4d, 0x56, 0x15, 0x4b, 0x54, 0x14, 0x4a, 0x52, 0x14, 0x4a, 0x51,
+    0x12, 0x48, 0x51, 0x11, 0x46, 0x4f, 0x11, 0x45, 0x4e, 0x11, 0x45, 0x4d, 0x10, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48,
+    0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42,
+    0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b,
+    0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34,
+    0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62,
+    0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f,
+    0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55,
+    0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f,
+    0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49,
+    0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42,
+    0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a,
+    0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30,
+    0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26,
+    0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a,
+    0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x01, 0x10, 0x13, 0x00, 0x0a, 0x0c, 0x2e, 0x47, 0x4b, 0xfe, 0xfe, 0xfe,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xf1, 0xf5, 0xf6, 0x88, 0xad, 0xb3, 0x77, 0xa2, 0xa9, 0x72, 0x9e, 0xa5, 0x6e, 0x9b, 0xa1, 0x6a, 0x97, 0x9e, 0x65, 0x94, 0x9b,
+    0x62, 0x91, 0x99, 0x5c, 0x8e, 0x95, 0x58, 0x8a, 0x92, 0x54, 0x86, 0x8f, 0x50, 0x84, 0x8c, 0x4d, 0x81, 0x89, 0x49, 0x7e, 0x86,
+    0x46, 0x7b, 0x84, 0x42, 0x78, 0x80, 0x3e, 0x75, 0x7d, 0x3b, 0x72, 0x7b, 0x37, 0x6f, 0x78, 0x34, 0x6d, 0x75, 0x32, 0x6a, 0x73,
+    0x2f, 0x67, 0x70, 0x2c, 0x65, 0x6e, 0x2a, 0x63, 0x6b, 0x28, 0x61, 0x6a, 0x25, 0x5e, 0x67, 0x24, 0x5d, 0x66, 0x22, 0x5a, 0x64,
+    0x20, 0x59, 0x61, 0x1e, 0x57, 0x60, 0x1d, 0x55, 0x5e, 0x1b, 0x53, 0x5c, 0x18, 0x51, 0x5a, 0x17, 0x50, 0x59, 0x17, 0x4f, 0x57,
+    0x16, 0x4d, 0x56, 0x15, 0x4b, 0x54, 0x15, 0x4a, 0x53, 0x14, 0x4a, 0x51, 0x12, 0x48, 0x51, 0x12, 0x47, 0x50, 0x11, 0x45, 0x4e,
+    0x11, 0x45, 0x4d, 0x10, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45,
+    0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f,
+    0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38,
+    0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61,
+    0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e,
+    0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b,
+    0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57,
+    0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52,
+    0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d,
+    0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46,
+    0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e,
+    0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36,
+    0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c,
+    0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21,
+    0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14,
+    0x01, 0x10, 0x13, 0x00, 0x0a, 0x0c, 0x1d, 0x34, 0x37, 0xf5, 0xf6, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcd, 0xdd, 0xe0, 0x7d, 0xa6, 0xac, 0x78, 0xa2, 0xa9,
+    0x73, 0x9e, 0xa6, 0x70, 0x9c, 0xa3, 0x6b, 0x98, 0x9f, 0x66, 0x95, 0x9c, 0x63, 0x92, 0x9a, 0x5d, 0x8e, 0x96, 0x5a, 0x8b, 0x94,
+    0x55, 0x87, 0x90, 0x51, 0x85, 0x8d, 0x4d, 0x81, 0x89, 0x4a, 0x7f, 0x87, 0x47, 0x7c, 0x84, 0x43, 0x78, 0x81, 0x3f, 0x76, 0x7e,
+    0x3b, 0x72, 0x7b, 0x38, 0x70, 0x79, 0x35, 0x6d, 0x76, 0x33, 0x6a, 0x74, 0x30, 0x68, 0x71, 0x2d, 0x65, 0x6e, 0x2a, 0x63, 0x6b,
+    0x28, 0x61, 0x6a, 0x26, 0x5f, 0x68, 0x24, 0x5d, 0x66, 0x22, 0x5a, 0x64, 0x20, 0x59, 0x61, 0x1f, 0x57, 0x61, 0x1d, 0x55, 0x5e,
+    0x1b, 0x53, 0x5c, 0x19, 0x52, 0x5a, 0x18, 0x51, 0x5a, 0x17, 0x4f, 0x58, 0x17, 0x4e, 0x56, 0x16, 0x4c, 0x55, 0x15, 0x4a, 0x53,
+    0x14, 0x4a, 0x51, 0x12, 0x48, 0x51, 0x12, 0x47, 0x50, 0x11, 0x45, 0x4e, 0x11, 0x45, 0x4d, 0x10, 0x43, 0x4b, 0x0e, 0x41, 0x49,
+    0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43,
+    0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c,
+    0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35,
+    0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x8e, 0xb4, 0xba, 0xb4, 0xcd, 0xd1, 0x28, 0x72, 0x7c, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x21, 0x6c, 0x77, 0xb1, 0xcb, 0xcf, 0x94, 0xb7, 0xbd, 0x09, 0x5b, 0x67, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x51, 0x8a, 0x93, 0xbb, 0xd1, 0xd4,
+    0x64, 0x97, 0x9e, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60,
+    0x5d, 0x90, 0x97, 0x0a, 0x57, 0x62, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x44, 0x7c, 0x83, 0x8c, 0xae, 0xb3, 0x48, 0x7d, 0x85,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55,
+    0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50,
+    0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x36, 0x69, 0x70, 0x30, 0x63, 0x6b, 0x04, 0x41, 0x4a,
+    0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43,
+    0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b,
+    0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x10, 0x3c, 0x41, 0x97, 0xa9, 0xac, 0xb0, 0xbd, 0xbf, 0xaf, 0xbc, 0xbe, 0xaf, 0xbc, 0xbe,
+    0xaf, 0xbb, 0xbd, 0xaf, 0xbb, 0xbd, 0xb0, 0xbc, 0xbd, 0x98, 0xa7, 0xa9, 0x5c, 0x72, 0x75, 0x11, 0x30, 0x35, 0x02, 0x23, 0x27,
+    0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c,
+    0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x01, 0x10, 0x13, 0x00, 0x0b, 0x0d, 0x10, 0x24, 0x27,
+    0xdc, 0xdf, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xa5, 0xc2, 0xc6, 0x7d, 0xa7, 0xad, 0x79, 0xa3, 0xaa, 0x75, 0xa0, 0xa7, 0x70, 0x9d, 0xa3, 0x6c, 0x99, 0xa0,
+    0x67, 0x96, 0x9d, 0x64, 0x92, 0x9a, 0x5e, 0x8f, 0x97, 0x5a, 0x8c, 0x94, 0x56, 0x88, 0x90, 0x52, 0x85, 0x8d, 0x4e, 0x82, 0x8a,
+    0x4b, 0x7f, 0x88, 0x48, 0x7c, 0x85, 0x44, 0x79, 0x82, 0x40, 0x76, 0x7e, 0x3c, 0x73, 0x7c, 0x39, 0x71, 0x79, 0x35, 0x6d, 0x76,
+    0x33, 0x6a, 0x74, 0x30, 0x68, 0x71, 0x2e, 0x66, 0x6f, 0x2b, 0x63, 0x6c, 0x28, 0x61, 0x6a, 0x26, 0x60, 0x69, 0x25, 0x5d, 0x66,
+    0x23, 0x5b, 0x64, 0x21, 0x5a, 0x62, 0x1f, 0x57, 0x61, 0x1d, 0x55, 0x5e, 0x1c, 0x54, 0x5d, 0x19, 0x52, 0x5a, 0x18, 0x51, 0x5a,
+    0x17, 0x4f, 0x58, 0x17, 0x4e, 0x56, 0x16, 0x4c, 0x55, 0x15, 0x4a, 0x53, 0x14, 0x4a, 0x51, 0x12, 0x48, 0x51, 0x12, 0x47, 0x50,
+    0x11, 0x45, 0x4e, 0x11, 0x45, 0x4d, 0x10, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46,
+    0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40,
+    0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39,
+    0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0xd7, 0xe5, 0xe7,
+    0xff, 0xff, 0xff, 0x3b, 0x7e, 0x87, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x30, 0x76, 0x80, 0xff, 0xff, 0xff,
+    0xe0, 0xea, 0xec, 0x0b, 0x5c, 0x68, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x79, 0xa5, 0xac, 0xff, 0xff, 0xff, 0x96, 0xb8, 0xbd, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61,
+    0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0xd0, 0xdf, 0xe1, 0x8e, 0xb1, 0xb6, 0x06, 0x53, 0x5e,
+    0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b,
+    0x05, 0x50, 0x5b, 0x84, 0xa9, 0xae, 0xff, 0xff, 0xff, 0x8a, 0xac, 0xb2, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57,
+    0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53,
+    0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d,
+    0x05, 0x43, 0x4d, 0xa2, 0xba, 0xbd, 0xa4, 0xbb, 0xbe, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47,
+    0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f,
+    0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x17, 0x41, 0x47,
+    0xe7, 0xeb, 0xec, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1, 0xd7, 0xd8, 0x3a, 0x53, 0x56, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23,
+    0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16,
+    0x01, 0x12, 0x14, 0x01, 0x10, 0x13, 0x00, 0x0d, 0x0f, 0x07, 0x18, 0x1c, 0xc5, 0xcc, 0xcd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0xf6, 0xf7, 0x90, 0xb3, 0xb8, 0x7f, 0xa8, 0xae,
+    0x7b, 0xa4, 0xab, 0x76, 0xa0, 0xa7, 0x71, 0x9d, 0xa4, 0x6d, 0x99, 0xa0, 0x68, 0x96, 0x9d, 0x64, 0x93, 0x9b, 0x5f, 0x90, 0x97,
+    0x5b, 0x8c, 0x95, 0x57, 0x88, 0x91, 0x53, 0x86, 0x8e, 0x4e, 0x82, 0x8a, 0x4b, 0x7f, 0x88, 0x48, 0x7c, 0x85, 0x43, 0x78, 0x81,
+    0x40, 0x76, 0x7e, 0x3d, 0x74, 0x7c, 0x39, 0x71, 0x79, 0x36, 0x6e, 0x76, 0x34, 0x6b, 0x75, 0x31, 0x68, 0x72, 0x2e, 0x66, 0x6f,
+    0x2b, 0x63, 0x6c, 0x29, 0x62, 0x6b, 0x26, 0x5f, 0x68, 0x25, 0x5d, 0x66, 0x23, 0x5b, 0x64, 0x21, 0x5a, 0x62, 0x1f, 0x57, 0x61,
+    0x1d, 0x55, 0x5e, 0x1c, 0x54, 0x5d, 0x19, 0x52, 0x5a, 0x18, 0x51, 0x5a, 0x17, 0x4f, 0x58, 0x17, 0x4e, 0x56, 0x16, 0x4c, 0x55,
+    0x15, 0x4a, 0x53, 0x14, 0x4a, 0x51, 0x12, 0x48, 0x51, 0x12, 0x47, 0x50, 0x11, 0x45, 0x4e, 0x11, 0x45, 0x4d, 0x10, 0x43, 0x4b,
+    0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44,
+    0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d,
+    0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36,
+    0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0xce, 0xdf, 0xe1, 0xff, 0xff, 0xff, 0x39, 0x7c, 0x86, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x2e, 0x75, 0x7f, 0xff, 0xff, 0xff, 0xd6, 0xe4, 0xe6, 0x0b, 0x5c, 0x68, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x74, 0xa2, 0xa9,
+    0xff, 0xff, 0xff, 0x90, 0xb4, 0xb9, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60,
+    0x06, 0x54, 0x60, 0xc7, 0xd9, 0xdb, 0xff, 0xff, 0xff, 0x6e, 0x9a, 0xa1, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d,
+    0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x7e, 0xa4, 0xaa, 0xff, 0xff, 0xff,
+    0x83, 0xa8, 0xad, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56,
+    0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51,
+    0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x1b, 0x53, 0x5c, 0xee, 0xf2, 0xf3, 0xee, 0xf2, 0xf3,
+    0x1a, 0x51, 0x5a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44,
+    0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c,
+    0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x16, 0x40, 0x46, 0xe1, 0xe7, 0xe7, 0xf7, 0xf8, 0xf9, 0x66, 0x7f, 0x83,
+    0x4d, 0x6a, 0x6e, 0x50, 0x6b, 0x6f, 0x4f, 0x6a, 0x6e, 0x4f, 0x69, 0x6d, 0x74, 0x88, 0x8a, 0xcc, 0xd3, 0xd4, 0xff, 0xff, 0xff,
+    0xe7, 0xea, 0xeb, 0x25, 0x3f, 0x44, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e,
+    0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x01, 0x10, 0x13, 0x01, 0x0d, 0x10,
+    0x03, 0x10, 0x12, 0xb3, 0xbb, 0xbc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xde, 0xe9, 0xea, 0x85, 0xac, 0xb2, 0x80, 0xa9, 0xae, 0x7c, 0xa5, 0xab, 0x77, 0xa1, 0xa8, 0x72, 0x9e, 0xa4,
+    0x6e, 0x9a, 0xa1, 0x69, 0x97, 0x9e, 0x65, 0x94, 0x9b, 0x60, 0x90, 0x98, 0x5c, 0x8d, 0x95, 0x58, 0x89, 0x92, 0x54, 0x86, 0x8e,
+    0x4f, 0x82, 0x8b, 0x4c, 0x80, 0x88, 0x49, 0x7d, 0x86, 0x45, 0x7a, 0x82, 0x41, 0x77, 0x7f, 0x3d, 0x74, 0x7c, 0x3a, 0x72, 0x7a,
+    0x36, 0x6e, 0x76, 0x34, 0x6b, 0x75, 0x31, 0x68, 0x72, 0x2e, 0x66, 0x6f, 0x2b, 0x63, 0x6c, 0x2a, 0x63, 0x6b, 0x26, 0x60, 0x69,
+    0x24, 0x5d, 0x66, 0x23, 0x5b, 0x64, 0x21, 0x5a, 0x62, 0x1f, 0x57, 0x61, 0x1d, 0x55, 0x5e, 0x1c, 0x54, 0x5d, 0x19, 0x52, 0x5a,
+    0x18, 0x51, 0x5a, 0x17, 0x4f, 0x58, 0x17, 0x4e, 0x56, 0x16, 0x4c, 0x55, 0x15, 0x4a, 0x53, 0x14, 0x4a, 0x51, 0x12, 0x48, 0x51,
+    0x12, 0x47, 0x50, 0x11, 0x45, 0x4e, 0x11, 0x45, 0x4d, 0x10, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47,
+    0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41,
+    0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a,
+    0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30,
+    0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0xce, 0xdf, 0xe1, 0xff, 0xff, 0xff, 0x39, 0x7c, 0x86, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x2e, 0x75, 0x7f,
+    0xff, 0xff, 0xff, 0xd6, 0xe4, 0xe6, 0x0b, 0x5c, 0x68, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x74, 0xa2, 0xa9, 0xff, 0xff, 0xff, 0x90, 0xb4, 0xb9, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61,
+    0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0xc4, 0xd7, 0xd9, 0xff, 0xff, 0xff,
+    0xfd, 0xfe, 0xfe, 0x5b, 0x8e, 0x95, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x7e, 0xa4, 0xaa, 0xff, 0xff, 0xff, 0x83, 0xa8, 0xad, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58,
+    0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54,
+    0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e,
+    0x05, 0x44, 0x4d, 0x6c, 0x90, 0x96, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6f, 0x92, 0x97, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48,
+    0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41,
+    0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38,
+    0x16, 0x40, 0x46, 0xe3, 0xe8, 0xe9, 0xf1, 0xf4, 0xf4, 0x19, 0x3f, 0x45, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f,
+    0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x0a, 0x2b, 0x30, 0xb3, 0xbd, 0xbe, 0xff, 0xff, 0xff, 0x91, 0x9e, 0xa1, 0x02, 0x20, 0x24,
+    0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18,
+    0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x01, 0x10, 0x13, 0x01, 0x0e, 0x10, 0x01, 0x0c, 0x0e, 0xa0, 0xab, 0xac, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc8, 0xda, 0xdd, 0x86, 0xac, 0xb2,
+    0x81, 0xa9, 0xaf, 0x7d, 0xa5, 0xac, 0x78, 0xa2, 0xa9, 0x73, 0x9e, 0xa5, 0x6f, 0x9b, 0xa1, 0x6a, 0x97, 0x9e, 0x65, 0x94, 0x9b,
+    0x61, 0x91, 0x98, 0x5c, 0x8d, 0x95, 0x59, 0x8a, 0x92, 0x54, 0x86, 0x8e, 0x50, 0x83, 0x8b, 0x4d, 0x81, 0x89, 0x4a, 0x7e, 0x86,
+    0x46, 0x7a, 0x83, 0x42, 0x78, 0x80, 0x3e, 0x74, 0x7d, 0x3a, 0x72, 0x7a, 0x37, 0x6f, 0x77, 0x34, 0x6c, 0x75, 0x31, 0x68, 0x72,
+    0x2f, 0x67, 0x70, 0x2c, 0x64, 0x6d, 0x29, 0x62, 0x6b, 0x27, 0x60, 0x69, 0x25, 0x5d, 0x66, 0x22, 0x5a, 0x64, 0x20, 0x59, 0x61,
+    0x1f, 0x57, 0x61, 0x1e, 0x56, 0x5f, 0x1c, 0x54, 0x5d, 0x19, 0x52, 0x5a, 0x18, 0x51, 0x5a, 0x17, 0x4f, 0x58, 0x17, 0x4e, 0x56,
+    0x16, 0x4c, 0x55, 0x15, 0x4a, 0x53, 0x14, 0x4a, 0x51, 0x13, 0x49, 0x51, 0x12, 0x47, 0x50, 0x11, 0x45, 0x4e, 0x11, 0x45, 0x4d,
+    0x10, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45,
+    0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e,
+    0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37,
+    0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0xce, 0xdf, 0xe1, 0xff, 0xff, 0xff, 0x39, 0x7c, 0x86,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x2e, 0x75, 0x7f, 0xff, 0xff, 0xff, 0xd6, 0xe4, 0xe6, 0x0b, 0x5c, 0x68,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x74, 0xa2, 0xa9, 0xff, 0xff, 0xff, 0x90, 0xb4, 0xb9, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60,
+    0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0xc4, 0xd7, 0xd9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0xf9, 0xf9, 0x4a, 0x82, 0x8a,
+    0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x7e, 0xa4, 0xaa,
+    0xff, 0xff, 0xff, 0x83, 0xa8, 0xad, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56,
+    0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51,
+    0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x08, 0x46, 0x4f, 0xcb, 0xd8, 0xda, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xcf, 0xda, 0xdc, 0x0a, 0x44, 0x4d, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45,
+    0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d,
+    0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x16, 0x40, 0x46, 0xe3, 0xe8, 0xe9, 0xf2, 0xf4, 0xf5,
+    0x23, 0x47, 0x4d, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a,
+    0x3c, 0x56, 0x5a, 0xff, 0xff, 0xff, 0xd1, 0xd7, 0xd8, 0x06, 0x23, 0x27, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f,
+    0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x01, 0x10, 0x13,
+    0x01, 0x0e, 0x10, 0x01, 0x0c, 0x0e, 0x88, 0x95, 0x97, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb4, 0xcd, 0xd0, 0x87, 0xad, 0xb3, 0x82, 0xaa, 0xb0, 0x7d, 0xa6, 0xad, 0x79, 0xa2, 0xa9,
+    0x74, 0x9f, 0xa6, 0x70, 0x9b, 0xa2, 0x6b, 0x98, 0x9f, 0x66, 0x94, 0x9c, 0x62, 0x92, 0x99, 0x5d, 0x8e, 0x96, 0x59, 0x8a, 0x92,
+    0x55, 0x87, 0x8f, 0x50, 0x83, 0x8b, 0x4d, 0x81, 0x89, 0x4a, 0x7e, 0x86, 0x46, 0x7a, 0x83, 0x42, 0x78, 0x80, 0x3e, 0x74, 0x7d,
+    0x3b, 0x72, 0x7a, 0x37, 0x6f, 0x77, 0x34, 0x6c, 0x75, 0x32, 0x69, 0x72, 0x2f, 0x67, 0x70, 0x2c, 0x64, 0x6d, 0x2a, 0x63, 0x6b,
+    0x26, 0x60, 0x69, 0x26, 0x5e, 0x67, 0x24, 0x5c, 0x65, 0x22, 0x5a, 0x63, 0x20, 0x58, 0x61, 0x1e, 0x56, 0x5f, 0x1c, 0x54, 0x5d,
+    0x1a, 0x53, 0x5b, 0x18, 0x51, 0x5a, 0x17, 0x4f, 0x58, 0x17, 0x4e, 0x56, 0x16, 0x4c, 0x55, 0x15, 0x4a, 0x53, 0x14, 0x4a, 0x51,
+    0x13, 0x49, 0x51, 0x12, 0x47, 0x50, 0x11, 0x45, 0x4e, 0x11, 0x45, 0x4d, 0x10, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48,
+    0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42,
+    0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b,
+    0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34,
+    0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0xce, 0xdf, 0xe1, 0xff, 0xff, 0xff, 0x39, 0x7c, 0x86, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x2e, 0x75, 0x7f, 0xff, 0xff, 0xff, 0xd6, 0xe4, 0xe6, 0x0b, 0x5c, 0x68, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x74, 0xa2, 0xa9, 0xff, 0xff, 0xff, 0x90, 0xb4, 0xb9,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62,
+    0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0xc4, 0xd7, 0xd9,
+    0xff, 0xff, 0xff, 0xdc, 0xe7, 0xe8, 0xff, 0xff, 0xff, 0xec, 0xf2, 0xf3, 0x3a, 0x77, 0x7f, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x7e, 0xa4, 0xaa, 0xff, 0xff, 0xff, 0x83, 0xa8, 0xad, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55,
+    0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f,
+    0x05, 0x45, 0x4e, 0x44, 0x73, 0x7a, 0xfe, 0xfe, 0xfe, 0xf2, 0xf5, 0xf6, 0xf5, 0xf8, 0xf8, 0xff, 0xff, 0xff, 0x4a, 0x75, 0x7c,
+    0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42,
+    0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a,
+    0x03, 0x32, 0x38, 0x16, 0x40, 0x46, 0xe3, 0xe8, 0xe9, 0xf2, 0xf4, 0xf5, 0x23, 0x47, 0x4d, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30,
+    0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x1b, 0x39, 0x3d, 0xfe, 0xfe, 0xfe, 0xe5, 0xe8, 0xe9,
+    0x0a, 0x27, 0x2b, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a,
+    0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x01, 0x10, 0x13, 0x01, 0x0e, 0x10, 0x00, 0x0b, 0x0d, 0x78, 0x87, 0x8a,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa6, 0xc3, 0xc7,
+    0x87, 0xad, 0xb3, 0x82, 0xaa, 0xb0, 0x7d, 0xa6, 0xad, 0x79, 0xa2, 0xa9, 0x74, 0x9f, 0xa6, 0x70, 0x9b, 0xa2, 0x6c, 0x99, 0xa0,
+    0x67, 0x95, 0x9d, 0x62, 0x92, 0x99, 0x5e, 0x8e, 0x97, 0x5a, 0x8a, 0x93, 0x55, 0x87, 0x8f, 0x51, 0x84, 0x8c, 0x4d, 0x81, 0x89,
+    0x4a, 0x7e, 0x86, 0x45, 0x7a, 0x82, 0x42, 0x78, 0x80, 0x3f, 0x75, 0x7e, 0x3b, 0x72, 0x7a, 0x38, 0x6f, 0x78, 0x34, 0x6c, 0x75,
+    0x32, 0x69, 0x72, 0x2f, 0x67, 0x70, 0x2d, 0x65, 0x6d, 0x2a, 0x63, 0x6b, 0x26, 0x60, 0x69, 0x26, 0x5e, 0x67, 0x24, 0x5c, 0x65,
+    0x22, 0x5a, 0x63, 0x20, 0x58, 0x61, 0x1e, 0x56, 0x5f, 0x1c, 0x54, 0x5d, 0x1a, 0x53, 0x5b, 0x18, 0x51, 0x5a, 0x17, 0x4f, 0x58,
+    0x17, 0x4e, 0x56, 0x16, 0x4c, 0x55, 0x15, 0x4a, 0x53, 0x14, 0x4a, 0x51, 0x13, 0x49, 0x51, 0x12, 0x47, 0x50, 0x11, 0x45, 0x4e,
+    0x11, 0x45, 0x4d, 0x10, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45,
+    0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f,
+    0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38,
+    0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0xce, 0xdf, 0xe1, 0xff, 0xff, 0xff,
+    0x39, 0x7c, 0x86, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x2e, 0x75, 0x7f, 0xff, 0xff, 0xff, 0xd6, 0xe4, 0xe6,
+    0x0b, 0x5c, 0x68, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x74, 0xa2, 0xa9, 0xff, 0xff, 0xff, 0x90, 0xb4, 0xb9, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61,
+    0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0xc5, 0xd7, 0xda, 0xff, 0xff, 0xff, 0x4b, 0x83, 0x8b, 0xb4, 0xcb, 0xce,
+    0xff, 0xff, 0xff, 0xe0, 0xe9, 0xeb, 0x2a, 0x6c, 0x75, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b,
+    0x7e, 0xa4, 0xaa, 0xff, 0xff, 0xff, 0x83, 0xa8, 0xad, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57,
+    0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52,
+    0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0xa3, 0xba, 0xbd, 0xff, 0xff, 0xff,
+    0x94, 0xaf, 0xb2, 0x89, 0xa6, 0xaa, 0xff, 0xff, 0xff, 0xae, 0xc2, 0xc4, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46,
+    0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e,
+    0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x16, 0x40, 0x46, 0xe3, 0xe8, 0xe9,
+    0xf2, 0xf4, 0xf5, 0x23, 0x47, 0x4d, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c,
+    0x03, 0x25, 0x2a, 0x3a, 0x54, 0x58, 0xff, 0xff, 0xff, 0xd1, 0xd7, 0xd8, 0x06, 0x23, 0x27, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21,
+    0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14,
+    0x01, 0x10, 0x13, 0x01, 0x0e, 0x11, 0x00, 0x0b, 0x0d, 0x6b, 0x7c, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0xbf, 0xc4, 0x88, 0xae, 0xb4, 0x83, 0xaa, 0xb0, 0x7e, 0xa7, 0xad,
+    0x7a, 0xa3, 0xaa, 0x75, 0xa0, 0xa6, 0x70, 0x9c, 0xa3, 0x6c, 0x99, 0xa0, 0x67, 0x95, 0x9d, 0x63, 0x92, 0x9a, 0x5e, 0x8e, 0x97,
+    0x5a, 0x8a, 0x93, 0x56, 0x88, 0x90, 0x51, 0x84, 0x8c, 0x4d, 0x81, 0x89, 0x4b, 0x7e, 0x87, 0x47, 0x7b, 0x84, 0x42, 0x78, 0x80,
+    0x3f, 0x75, 0x7e, 0x3b, 0x72, 0x7a, 0x38, 0x6f, 0x78, 0x34, 0x6c, 0x75, 0x32, 0x69, 0x72, 0x2f, 0x67, 0x70, 0x2d, 0x65, 0x6d,
+    0x2a, 0x63, 0x6b, 0x27, 0x60, 0x69, 0x26, 0x5e, 0x67, 0x24, 0x5c, 0x65, 0x22, 0x5a, 0x63, 0x20, 0x58, 0x61, 0x1e, 0x56, 0x5f,
+    0x1d, 0x55, 0x5d, 0x1a, 0x53, 0x5b, 0x18, 0x51, 0x5a, 0x17, 0x4f, 0x58, 0x17, 0x4e, 0x56, 0x16, 0x4c, 0x55, 0x15, 0x4a, 0x53,
+    0x14, 0x4a, 0x51, 0x13, 0x49, 0x51, 0x12, 0x47, 0x50, 0x11, 0x45, 0x4e, 0x11, 0x45, 0x4d, 0x10, 0x43, 0x4b, 0x0e, 0x41, 0x49,
+    0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43,
+    0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c,
+    0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35,
+    0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0xce, 0xdf, 0xe1, 0xff, 0xff, 0xff, 0x39, 0x7c, 0x86, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x2e, 0x75, 0x7f, 0xff, 0xff, 0xff, 0xd6, 0xe4, 0xe6, 0x0b, 0x5c, 0x68, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x74, 0xa2, 0xa9, 0xff, 0xff, 0xff,
+    0x90, 0xb4, 0xb9, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60,
+    0xc5, 0xd7, 0xda, 0xff, 0xff, 0xff, 0x38, 0x75, 0x7e, 0x12, 0x5b, 0x66, 0xcb, 0xdb, 0xde, 0xff, 0xff, 0xff, 0xd2, 0xe0, 0xe2,
+    0x1d, 0x61, 0x6b, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x7e, 0xa4, 0xaa, 0xff, 0xff, 0xff, 0x83, 0xa8, 0xad,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55,
+    0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50,
+    0x05, 0x46, 0x4f, 0x21, 0x5a, 0x62, 0xf1, 0xf5, 0xf5, 0xfe, 0xfe, 0xfe, 0x32, 0x66, 0x6d, 0x26, 0x5c, 0x64, 0xf9, 0xfb, 0xfb,
+    0xf7, 0xf9, 0xf9, 0x29, 0x5c, 0x63, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43,
+    0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b,
+    0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x16, 0x40, 0x46, 0xe3, 0xe8, 0xe9, 0xf2, 0xf4, 0xf5, 0x23, 0x47, 0x4d, 0x03, 0x2c, 0x32,
+    0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x12, 0x32, 0x37, 0xb9, 0xc2, 0xc3, 0xff, 0xff, 0xff,
+    0x89, 0x97, 0x9a, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c,
+    0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x01, 0x10, 0x13, 0x01, 0x0e, 0x11, 0x00, 0x0a, 0x0c,
+    0x64, 0x75, 0x78, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0xfc, 0xfc,
+    0x9d, 0xbc, 0xc1, 0x89, 0xae, 0xb4, 0x83, 0xaa, 0xb0, 0x7e, 0xa7, 0xad, 0x7a, 0xa3, 0xaa, 0x75, 0xa0, 0xa6, 0x70, 0x9c, 0xa3,
+    0x6c, 0x99, 0xa0, 0x68, 0x96, 0x9d, 0x63, 0x92, 0x9a, 0x5e, 0x8e, 0x97, 0x5a, 0x8b, 0x93, 0x56, 0x88, 0x90, 0x52, 0x84, 0x8c,
+    0x4d, 0x81, 0x89, 0x4b, 0x7e, 0x87, 0x47, 0x7b, 0x84, 0x42, 0x78, 0x80, 0x3f, 0x75, 0x7e, 0x3b, 0x72, 0x7a, 0x38, 0x6f, 0x78,
+    0x35, 0x6c, 0x76, 0x32, 0x69, 0x72, 0x30, 0x68, 0x70, 0x2d, 0x65, 0x6d, 0x2a, 0x63, 0x6b, 0x27, 0x60, 0x69, 0x26, 0x5e, 0x67,
+    0x24, 0x5c, 0x65, 0x22, 0x5a, 0x63, 0x20, 0x58, 0x61, 0x1e, 0x56, 0x5f, 0x1d, 0x55, 0x5d, 0x1a, 0x53, 0x5b, 0x18, 0x51, 0x5a,
+    0x17, 0x4f, 0x58, 0x17, 0x4e, 0x56, 0x16, 0x4c, 0x55, 0x15, 0x4a, 0x53, 0x15, 0x4a, 0x52, 0x13, 0x49, 0x51, 0x12, 0x47, 0x50,
+    0x11, 0x45, 0x4e, 0x11, 0x45, 0x4d, 0x10, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46,
+    0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40,
+    0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39,
+    0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0xce, 0xdf, 0xe1,
+    0xff, 0xff, 0xff, 0x39, 0x7c, 0x86, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x2e, 0x75, 0x7f, 0xff, 0xff, 0xff,
+    0xd6, 0xe4, 0xe6, 0x0b, 0x5c, 0x68, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x74, 0xa2, 0xa9, 0xff, 0xff, 0xff, 0x90, 0xb4, 0xb9, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61,
+    0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0xc5, 0xd7, 0xda, 0xff, 0xff, 0xff, 0x43, 0x7d, 0x85,
+    0x06, 0x53, 0x5e, 0x23, 0x68, 0x72, 0xd8, 0xe4, 0xe6, 0xff, 0xff, 0xff, 0xc3, 0xd5, 0xd8, 0x11, 0x59, 0x64, 0x05, 0x51, 0x5b,
+    0x05, 0x50, 0x5b, 0x7e, 0xa4, 0xaa, 0xff, 0xff, 0xff, 0x83, 0xa8, 0xad, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57,
+    0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53,
+    0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x78, 0x9a, 0x9f, 0xff, 0xff, 0xff,
+    0xc2, 0xd1, 0xd4, 0x05, 0x44, 0x4d, 0x04, 0x42, 0x4b, 0xb4, 0xc6, 0xc9, 0xff, 0xff, 0xff, 0x89, 0xa5, 0xa9, 0x04, 0x3e, 0x47,
+    0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f,
+    0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x16, 0x40, 0x46,
+    0xe3, 0xe8, 0xe9, 0xf2, 0xf4, 0xf5, 0x20, 0x45, 0x4a, 0x33, 0x55, 0x59, 0x47, 0x64, 0x68, 0x46, 0x62, 0x66, 0x55, 0x6e, 0x72,
+    0x84, 0x96, 0x98, 0xdb, 0xe0, 0xe1, 0xff, 0xff, 0xff, 0xcd, 0xd4, 0xd5, 0x18, 0x34, 0x39, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23,
+    0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16,
+    0x01, 0x12, 0x14, 0x01, 0x10, 0x13, 0x01, 0x0e, 0x11, 0x00, 0x0a, 0x0c, 0x61, 0x73, 0x76, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0xfb, 0xfb, 0x9c, 0xbc, 0xc1, 0x89, 0xae, 0xb4, 0x84, 0xab, 0xb1,
+    0x7f, 0xa7, 0xae, 0x7b, 0xa4, 0xaa, 0x76, 0xa0, 0xa7, 0x71, 0x9d, 0xa3, 0x6d, 0x99, 0xa0, 0x68, 0x96, 0x9d, 0x63, 0x92, 0x9a,
+    0x5f, 0x8f, 0x97, 0x5a, 0x8b, 0x93, 0x56, 0x88, 0x90, 0x52, 0x84, 0x8c, 0x4d, 0x81, 0x89, 0x4b, 0x7e, 0x87, 0x47, 0x7b, 0x84,
+    0x42, 0x78, 0x80, 0x3f, 0x75, 0x7e, 0x3c, 0x73, 0x7b, 0x38, 0x6f, 0x78, 0x35, 0x6c, 0x76, 0x33, 0x6a, 0x73, 0x30, 0x68, 0x70,
+    0x2d, 0x65, 0x6d, 0x2a, 0x63, 0x6b, 0x27, 0x60, 0x69, 0x25, 0x5d, 0x66, 0x24, 0x5c, 0x65, 0x22, 0x5a, 0x63, 0x20, 0x58, 0x61,
+    0x1e, 0x56, 0x5f, 0x1d, 0x55, 0x5d, 0x1a, 0x53, 0x5b, 0x18, 0x51, 0x5a, 0x17, 0x4f, 0x58, 0x17, 0x4e, 0x56, 0x16, 0x4c, 0x55,
+    0x15, 0x4a, 0x53, 0x15, 0x4a, 0x52, 0x13, 0x49, 0x51, 0x12, 0x47, 0x50, 0x11, 0x45, 0x4e, 0x11, 0x45, 0x4d, 0x10, 0x43, 0x4b,
+    0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44,
+    0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d,
+    0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36,
+    0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0xce, 0xdf, 0xe1, 0xff, 0xff, 0xff, 0x39, 0x7c, 0x86, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x2e, 0x75, 0x7f, 0xff, 0xff, 0xff, 0xd6, 0xe4, 0xe6, 0x0b, 0x5c, 0x68, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x74, 0xa2, 0xa9,
+    0xff, 0xff, 0xff, 0x90, 0xb4, 0xb9, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60,
+    0x06, 0x54, 0x60, 0xc5, 0xd7, 0xda, 0xff, 0xff, 0xff, 0x42, 0x7c, 0x85, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x2f, 0x6f, 0x78,
+    0xe4, 0xec, 0xed, 0xff, 0xff, 0xff, 0xb3, 0xca, 0xcd, 0x0b, 0x55, 0x5f, 0x05, 0x50, 0x5b, 0x7e, 0xa4, 0xaa, 0xff, 0xff, 0xff,
+    0x83, 0xa8, 0xad, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56,
+    0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51,
+    0x05, 0x47, 0x50, 0x0c, 0x4b, 0x54, 0xd6, 0xe0, 0xe2, 0xff, 0xff, 0xff, 0x61, 0x88, 0x8f, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b,
+    0x4f, 0x7a, 0x80, 0xff, 0xff, 0xff, 0xe1, 0xe8, 0xe9, 0x14, 0x4a, 0x53, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44,
+    0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c,
+    0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x16, 0x40, 0x46, 0xe3, 0xe8, 0xe9, 0xf2, 0xf4, 0xf5, 0x19, 0x3f, 0x45,
+    0x4e, 0x6b, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0x9e, 0xab, 0xad,
+    0x17, 0x35, 0x39, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e,
+    0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x01, 0x10, 0x13, 0x01, 0x0e, 0x11,
+    0x00, 0x0a, 0x0c, 0x61, 0x73, 0x76, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xfb, 0xfc, 0xfc, 0x9e, 0xbd, 0xc2, 0x89, 0xae, 0xb4, 0x84, 0xab, 0xb1, 0x7f, 0xa7, 0xae, 0x7b, 0xa4, 0xaa, 0x76, 0xa0, 0xa7,
+    0x71, 0x9d, 0xa3, 0x6d, 0x99, 0xa0, 0x68, 0x96, 0x9d, 0x64, 0x93, 0x9a, 0x5f, 0x8f, 0x97, 0x5a, 0x8b, 0x93, 0x56, 0x88, 0x90,
+    0x52, 0x84, 0x8c, 0x4d, 0x81, 0x89, 0x4b, 0x7e, 0x87, 0x47, 0x7b, 0x84, 0x42, 0x78, 0x80, 0x3f, 0x75, 0x7e, 0x3c, 0x73, 0x7b,
+    0x38, 0x6f, 0x78, 0x35, 0x6c, 0x76, 0x33, 0x6a, 0x73, 0x30, 0x68, 0x70, 0x2d, 0x65, 0x6d, 0x2a, 0x63, 0x6b, 0x27, 0x60, 0x69,
+    0x25, 0x5d, 0x66, 0x24, 0x5c, 0x65, 0x22, 0x5a, 0x63, 0x20, 0x58, 0x61, 0x1e, 0x56, 0x5f, 0x1d, 0x55, 0x5d, 0x1a, 0x53, 0x5b,
+    0x18, 0x51, 0x5a, 0x17, 0x4f, 0x58, 0x17, 0x4e, 0x56, 0x16, 0x4c, 0x55, 0x15, 0x4a, 0x53, 0x15, 0x4a, 0x52, 0x13, 0x49, 0x51,
+    0x12, 0x47, 0x50, 0x11, 0x45, 0x4e, 0x11, 0x45, 0x4d, 0x10, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47,
+    0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41,
+    0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a,
+    0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30,
+    0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0xce, 0xdf, 0xe1, 0xff, 0xff, 0xff, 0x39, 0x7c, 0x86, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x2e, 0x75, 0x7f,
+    0xff, 0xff, 0xff, 0xd6, 0xe4, 0xe6, 0x0b, 0x5c, 0x68, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x74, 0xa2, 0xa9, 0xff, 0xff, 0xff, 0x90, 0xb4, 0xb9, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61,
+    0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0xc5, 0xd7, 0xda, 0xff, 0xff, 0xff,
+    0x42, 0x7c, 0x85, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x3a, 0x77, 0x7f, 0xec, 0xf2, 0xf3, 0xff, 0xff, 0xff,
+    0x9f, 0xbc, 0xc0, 0x05, 0x50, 0x5b, 0x7b, 0xa2, 0xa8, 0xff, 0xff, 0xff, 0x83, 0xa8, 0xad, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58,
+    0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54,
+    0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x4f, 0x7c, 0x83, 0xff, 0xff, 0xff,
+    0xe2, 0xe9, 0xea, 0x14, 0x4e, 0x57, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x0a, 0x45, 0x4e, 0xd2, 0xdd, 0xde, 0xff, 0xff, 0xff,
+    0x62, 0x87, 0x8c, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41,
+    0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38,
+    0x16, 0x40, 0x46, 0xe3, 0xe8, 0xe9, 0xf2, 0xf4, 0xf5, 0x22, 0x47, 0x4c, 0x03, 0x2c, 0x32, 0x6a, 0x81, 0x84, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xa4, 0xb1, 0xb3, 0x27, 0x44, 0x48, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24,
+    0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18,
+    0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x01, 0x10, 0x13, 0x01, 0x0e, 0x11, 0x00, 0x0b, 0x0c, 0x66, 0x77, 0x7a, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa2, 0xc0, 0xc4, 0x89, 0xae, 0xb4,
+    0x84, 0xab, 0xb1, 0x7f, 0xa7, 0xae, 0x7b, 0xa4, 0xaa, 0x76, 0xa0, 0xa7, 0x71, 0x9d, 0xa3, 0x6d, 0x99, 0xa0, 0x68, 0x96, 0x9d,
+    0x63, 0x92, 0x9a, 0x5f, 0x8f, 0x97, 0x5a, 0x8b, 0x93, 0x56, 0x88, 0x90, 0x52, 0x84, 0x8c, 0x4d, 0x81, 0x89, 0x4b, 0x7e, 0x87,
+    0x47, 0x7b, 0x84, 0x42, 0x78, 0x80, 0x3f, 0x75, 0x7e, 0x3c, 0x73, 0x7b, 0x38, 0x6f, 0x78, 0x35, 0x6c, 0x76, 0x33, 0x6a, 0x73,
+    0x30, 0x68, 0x70, 0x2d, 0x65, 0x6d, 0x2a, 0x63, 0x6b, 0x27, 0x60, 0x69, 0x25, 0x5d, 0x66, 0x24, 0x5c, 0x65, 0x22, 0x5a, 0x63,
+    0x20, 0x58, 0x61, 0x1e, 0x56, 0x5f, 0x1d, 0x55, 0x5d, 0x1a, 0x53, 0x5b, 0x18, 0x51, 0x5a, 0x17, 0x4f, 0x58, 0x17, 0x4e, 0x56,
+    0x16, 0x4c, 0x55, 0x15, 0x4a, 0x53, 0x15, 0x4a, 0x52, 0x13, 0x49, 0x51, 0x12, 0x47, 0x50, 0x11, 0x45, 0x4e, 0x11, 0x45, 0x4d,
+    0x10, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45,
+    0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e,
+    0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37,
+    0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0xce, 0xdf, 0xe1, 0xff, 0xff, 0xff, 0x39, 0x7c, 0x86,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x2f, 0x75, 0x7f, 0xff, 0xff, 0xff, 0xd5, 0xe3, 0xe5, 0x0a, 0x5c, 0x67,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x72, 0xa1, 0xa7, 0xff, 0xff, 0xff, 0x91, 0xb5, 0xba, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60,
+    0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0xc5, 0xd7, 0xda, 0xff, 0xff, 0xff, 0x42, 0x7c, 0x85, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e,
+    0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x47, 0x7f, 0x87, 0xf5, 0xf8, 0xf9, 0xff, 0xff, 0xff, 0x7b, 0xa2, 0xa8, 0x78, 0xa0, 0xa6,
+    0xff, 0xff, 0xff, 0x83, 0xa8, 0xad, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56,
+    0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51,
+    0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0xaf, 0xc4, 0xc6, 0xff, 0xff, 0xff, 0x88, 0xa6, 0xab, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c,
+    0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x6e, 0x91, 0x96, 0xff, 0xff, 0xff, 0xc5, 0xd2, 0xd4, 0x06, 0x40, 0x47, 0x04, 0x3d, 0x45,
+    0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d,
+    0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x16, 0x40, 0x46, 0xe3, 0xe8, 0xe9, 0xf2, 0xf4, 0xf5,
+    0x23, 0x47, 0x4d, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x8e, 0x9f, 0xa2, 0xff, 0xff, 0xff, 0xdb, 0xe1, 0xe1, 0x26, 0x43, 0x47,
+    0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f,
+    0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x01, 0x10, 0x13,
+    0x01, 0x0e, 0x11, 0x00, 0x0b, 0x0d, 0x6e, 0x7f, 0x82, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa9, 0xc5, 0xc9, 0x89, 0xae, 0xb4, 0x84, 0xab, 0xb1, 0x7f, 0xa7, 0xae, 0x7b, 0xa4, 0xaa,
+    0x76, 0xa0, 0xa7, 0x71, 0x9d, 0xa3, 0x6d, 0x99, 0xa0, 0x68, 0x96, 0x9d, 0x63, 0x92, 0x9a, 0x5e, 0x8e, 0x97, 0x5a, 0x8b, 0x93,
+    0x56, 0x88, 0x90, 0x52, 0x84, 0x8c, 0x4d, 0x81, 0x89, 0x4b, 0x7e, 0x87, 0x47, 0x7b, 0x84, 0x42, 0x78, 0x80, 0x3f, 0x75, 0x7e,
+    0x3b, 0x72, 0x7a, 0x38, 0x6f, 0x78, 0x35, 0x6c, 0x76, 0x33, 0x6a, 0x73, 0x30, 0x68, 0x70, 0x2d, 0x65, 0x6d, 0x2a, 0x63, 0x6b,
+    0x27, 0x60, 0x69, 0x25, 0x5d, 0x66, 0x24, 0x5c, 0x65, 0x22, 0x5a, 0x63, 0x20, 0x58, 0x61, 0x1e, 0x56, 0x5f, 0x1d, 0x55, 0x5d,
+    0x1a, 0x53, 0x5b, 0x18, 0x51, 0x5a, 0x17, 0x4f, 0x58, 0x17, 0x4e, 0x56, 0x16, 0x4c, 0x55, 0x15, 0x4a, 0x53, 0x15, 0x4a, 0x52,
+    0x13, 0x49, 0x51, 0x12, 0x47, 0x50, 0x11, 0x45, 0x4e, 0x11, 0x45, 0x4d, 0x10, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48,
+    0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42,
+    0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b,
+    0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34,
+    0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0xce, 0xdf, 0xe1, 0xff, 0xff, 0xff, 0x39, 0x7c, 0x86, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x29, 0x71, 0x7c, 0xff, 0xff, 0xff, 0xe0, 0xea, 0xec, 0x0a, 0x5c, 0x67, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x7b, 0xa7, 0xad, 0xff, 0xff, 0xff, 0x8d, 0xb2, 0xb7,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62,
+    0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0xc5, 0xd7, 0xda,
+    0xff, 0xff, 0xff, 0x42, 0x7c, 0x85, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c,
+    0x54, 0x88, 0x90, 0xfa, 0xfc, 0xfc, 0xff, 0xff, 0xff, 0xdb, 0xe6, 0xe7, 0xff, 0xff, 0xff, 0x83, 0xa8, 0xad, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55,
+    0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x2a, 0x62, 0x6a, 0xf6, 0xf8, 0xf9,
+    0xf9, 0xfb, 0xfb, 0x2c, 0x61, 0x69, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x1b, 0x51, 0x59,
+    0xe9, 0xee, 0xef, 0xfd, 0xfd, 0xfe, 0x3e, 0x6b, 0x71, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42,
+    0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a,
+    0x03, 0x32, 0x38, 0x16, 0x40, 0x46, 0xe3, 0xe8, 0xe9, 0xf2, 0xf4, 0xf5, 0x23, 0x47, 0x4d, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30,
+    0x07, 0x2c, 0x32, 0xb1, 0xbc, 0xbe, 0xff, 0xff, 0xff, 0xd5, 0xdb, 0xdc, 0x1d, 0x3a, 0x3f, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26,
+    0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a,
+    0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x01, 0x10, 0x13, 0x01, 0x0e, 0x10, 0x00, 0x0b, 0x0d, 0x7d, 0x8c, 0x8f,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb8, 0xcf, 0xd3,
+    0x88, 0xae, 0xb4, 0x83, 0xaa, 0xb0, 0x7e, 0xa7, 0xad, 0x7a, 0xa3, 0xaa, 0x75, 0xa0, 0xa6, 0x70, 0x9c, 0xa3, 0x6c, 0x99, 0xa0,
+    0x67, 0x95, 0x9d, 0x63, 0x92, 0x9a, 0x5e, 0x8e, 0x97, 0x5a, 0x8b, 0x93, 0x56, 0x88, 0x90, 0x51, 0x84, 0x8c, 0x4d, 0x81, 0x89,
+    0x4b, 0x7e, 0x87, 0x47, 0x7b, 0x84, 0x42, 0x78, 0x80, 0x3f, 0x75, 0x7e, 0x3b, 0x72, 0x7a, 0x38, 0x6f, 0x78, 0x35, 0x6c, 0x76,
+    0x32, 0x69, 0x72, 0x30, 0x68, 0x70, 0x2d, 0x65, 0x6d, 0x2a, 0x63, 0x6b, 0x27, 0x60, 0x69, 0x26, 0x5e, 0x67, 0x24, 0x5c, 0x65,
+    0x22, 0x5a, 0x63, 0x20, 0x58, 0x61, 0x1e, 0x56, 0x5f, 0x1d, 0x55, 0x5d, 0x1a, 0x53, 0x5b, 0x18, 0x51, 0x5a, 0x17, 0x4f, 0x58,
+    0x17, 0x4e, 0x56, 0x16, 0x4c, 0x55, 0x15, 0x4a, 0x53, 0x14, 0x4a, 0x51, 0x13, 0x49, 0x51, 0x12, 0x47, 0x50, 0x11, 0x45, 0x4e,
+    0x11, 0x45, 0x4d, 0x10, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45,
+    0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f,
+    0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38,
+    0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0xce, 0xdf, 0xe1, 0xff, 0xff, 0xff,
+    0x39, 0x7c, 0x86, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x12, 0x62, 0x6d, 0xe1, 0xeb, 0xec, 0xfc, 0xfd, 0xfd,
+    0x47, 0x85, 0x8d, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64,
+    0x07, 0x59, 0x65, 0xc7, 0xda, 0xdc, 0xff, 0xff, 0xff, 0x5f, 0x94, 0x9b, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61,
+    0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0xc5, 0xd7, 0xda, 0xff, 0xff, 0xff, 0x42, 0x7c, 0x85, 0x06, 0x53, 0x5e,
+    0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x63, 0x93, 0x99, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x83, 0xa8, 0xad, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57,
+    0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52,
+    0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x83, 0xa4, 0xa9, 0xff, 0xff, 0xff, 0xb0, 0xc4, 0xc7, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d,
+    0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x92, 0xab, 0xaf, 0xff, 0xff, 0xff, 0xa1, 0xb7, 0xba,
+    0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e,
+    0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x16, 0x40, 0x46, 0xe3, 0xe8, 0xe9,
+    0xf2, 0xf4, 0xf5, 0x23, 0x47, 0x4d, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x15, 0x37, 0x3d, 0xcf, 0xd5, 0xd6,
+    0xff, 0xff, 0xff, 0xc1, 0xc9, 0xca, 0x0d, 0x2c, 0x30, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21,
+    0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14,
+    0x01, 0x10, 0x13, 0x01, 0x0e, 0x10, 0x01, 0x0c, 0x0e, 0x90, 0x9d, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcc, 0xdd, 0xdf, 0x88, 0xae, 0xb4, 0x83, 0xaa, 0xb0, 0x7e, 0xa7, 0xad,
+    0x7a, 0xa3, 0xaa, 0x75, 0xa0, 0xa6, 0x70, 0x9c, 0xa3, 0x6c, 0x99, 0xa0, 0x67, 0x95, 0x9d, 0x63, 0x92, 0x9a, 0x5e, 0x8e, 0x97,
+    0x5a, 0x8a, 0x93, 0x56, 0x88, 0x90, 0x51, 0x84, 0x8c, 0x4d, 0x81, 0x89, 0x4b, 0x7e, 0x87, 0x47, 0x7b, 0x84, 0x42, 0x78, 0x80,
+    0x3f, 0x75, 0x7e, 0x3b, 0x72, 0x7a, 0x38, 0x6f, 0x78, 0x34, 0x6c, 0x75, 0x32, 0x69, 0x72, 0x2f, 0x67, 0x70, 0x2d, 0x65, 0x6d,
+    0x2a, 0x63, 0x6b, 0x26, 0x60, 0x69, 0x26, 0x5e, 0x67, 0x24, 0x5c, 0x65, 0x22, 0x5a, 0x63, 0x20, 0x58, 0x61, 0x1e, 0x56, 0x5f,
+    0x1c, 0x54, 0x5d, 0x1a, 0x53, 0x5b, 0x18, 0x51, 0x5a, 0x17, 0x4f, 0x58, 0x17, 0x4e, 0x56, 0x16, 0x4c, 0x55, 0x15, 0x4a, 0x53,
+    0x14, 0x4a, 0x51, 0x13, 0x49, 0x51, 0x12, 0x47, 0x50, 0x11, 0x45, 0x4e, 0x11, 0x45, 0x4d, 0x10, 0x43, 0x4b, 0x0e, 0x41, 0x49,
+    0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43,
+    0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c,
+    0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35,
+    0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0xce, 0xdf, 0xe1, 0xff, 0xff, 0xff, 0x2e, 0x75, 0x7f, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x82, 0xac, 0xb2, 0xff, 0xff, 0xff, 0xd9, 0xe6, 0xe7, 0x35, 0x78, 0x82, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x0f, 0x5e, 0x69, 0x93, 0xb6, 0xbc, 0xff, 0xff, 0xff, 0xdf, 0xe9, 0xeb,
+    0x16, 0x62, 0x6d, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60,
+    0xc5, 0xd7, 0xda, 0xff, 0xff, 0xff, 0x42, 0x7c, 0x85, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x74, 0x9e, 0xa4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x83, 0xa8, 0xad,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55,
+    0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x10, 0x4f, 0x59, 0xdf, 0xe7, 0xe8,
+    0xff, 0xff, 0xff, 0x4e, 0x7b, 0x81, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a,
+    0x04, 0x40, 0x49, 0x31, 0x62, 0x69, 0xf9, 0xfa, 0xfb, 0xf1, 0xf4, 0xf5, 0x22, 0x54, 0x5b, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43,
+    0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b,
+    0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x16, 0x40, 0x46, 0xe3, 0xe8, 0xe9, 0xf2, 0xf4, 0xf5, 0x23, 0x47, 0x4d, 0x03, 0x2c, 0x32,
+    0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x2c, 0x4a, 0x4e, 0xe6, 0xea, 0xea, 0xff, 0xff, 0xff, 0xa8, 0xb3, 0xb4,
+    0x04, 0x23, 0x28, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c,
+    0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x01, 0x10, 0x13, 0x01, 0x0e, 0x10, 0x01, 0x0d, 0x0f,
+    0xa6, 0xb1, 0xb2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xe1, 0xeb, 0xec, 0x87, 0xad, 0xb3, 0x82, 0xaa, 0xb0, 0x7d, 0xa6, 0xad, 0x79, 0xa2, 0xa9, 0x74, 0x9f, 0xa6, 0x70, 0x9b, 0xa2,
+    0x6b, 0x98, 0x9f, 0x66, 0x94, 0x9c, 0x62, 0x92, 0x99, 0x5d, 0x8e, 0x96, 0x5a, 0x8a, 0x93, 0x55, 0x87, 0x8f, 0x51, 0x84, 0x8c,
+    0x4d, 0x81, 0x89, 0x4a, 0x7e, 0x86, 0x46, 0x7a, 0x83, 0x42, 0x78, 0x80, 0x3e, 0x74, 0x7d, 0x3b, 0x72, 0x7a, 0x37, 0x6f, 0x77,
+    0x34, 0x6c, 0x75, 0x32, 0x69, 0x72, 0x2f, 0x67, 0x70, 0x2c, 0x64, 0x6d, 0x2a, 0x63, 0x6b, 0x26, 0x60, 0x69, 0x26, 0x5e, 0x67,
+    0x24, 0x5c, 0x65, 0x22, 0x5a, 0x63, 0x20, 0x58, 0x61, 0x1e, 0x56, 0x5f, 0x1c, 0x54, 0x5d, 0x1a, 0x53, 0x5b, 0x18, 0x51, 0x5a,
+    0x17, 0x4f, 0x58, 0x17, 0x4e, 0x56, 0x16, 0x4c, 0x55, 0x15, 0x4a, 0x53, 0x14, 0x4a, 0x51, 0x13, 0x49, 0x51, 0x12, 0x47, 0x50,
+    0x11, 0x45, 0x4e, 0x11, 0x45, 0x4d, 0x10, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46,
+    0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40,
+    0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39,
+    0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0xcd, 0xde, 0xe1,
+    0xff, 0xff, 0xff, 0x97, 0xbb, 0xc0, 0x7b, 0xa8, 0xaf, 0x7d, 0xa9, 0xb0, 0x7d, 0xa9, 0xb0, 0x7e, 0xaa, 0xb0, 0x77, 0xa6, 0xac,
+    0x1a, 0x68, 0x73, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x11, 0x61, 0x6d,
+    0xc1, 0xd5, 0xd8, 0xff, 0xff, 0xff, 0xf4, 0xf8, 0xf8, 0xa7, 0xc4, 0xc9, 0x80, 0xaa, 0xb0, 0x7b, 0xa7, 0xad, 0x92, 0xb6, 0xbb,
+    0xd4, 0xe2, 0xe4, 0xff, 0xff, 0xff, 0xf8, 0xfa, 0xfb, 0x4b, 0x86, 0x8e, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61,
+    0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0xc5, 0xd7, 0xda, 0xff, 0xff, 0xff, 0x42, 0x7c, 0x85,
+    0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b,
+    0x05, 0x50, 0x5b, 0x85, 0xaa, 0xaf, 0xff, 0xff, 0xff, 0x85, 0xa9, 0xae, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57,
+    0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53,
+    0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x5a, 0x86, 0x8c, 0xff, 0xff, 0xff, 0xd4, 0xdf, 0xe1, 0x0c, 0x4a, 0x53, 0x05, 0x44, 0x4d,
+    0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0xb4, 0xc5, 0xc8,
+    0xff, 0xff, 0xff, 0x7b, 0x99, 0x9d, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f,
+    0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x16, 0x40, 0x46,
+    0xe3, 0xe8, 0xe9, 0xf2, 0xf4, 0xf5, 0x23, 0x47, 0x4d, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e,
+    0x03, 0x27, 0x2c, 0x45, 0x5e, 0x62, 0xf8, 0xf9, 0xf9, 0xff, 0xff, 0xff, 0x8d, 0x9b, 0x9d, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23,
+    0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16,
+    0x01, 0x12, 0x14, 0x01, 0x10, 0x13, 0x01, 0x0d, 0x10, 0x03, 0x12, 0x15, 0xb8, 0xbf, 0xc1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0xf8, 0xf8, 0x93, 0xb5, 0xba, 0x81, 0xa9, 0xaf,
+    0x7d, 0xa5, 0xac, 0x78, 0xa2, 0xa9, 0x73, 0x9e, 0xa5, 0x70, 0x9b, 0xa2, 0x6b, 0x98, 0x9f, 0x66, 0x94, 0x9c, 0x61, 0x91, 0x98,
+    0x5d, 0x8e, 0x96, 0x59, 0x8a, 0x92, 0x55, 0x87, 0x8f, 0x50, 0x83, 0x8b, 0x4d, 0x81, 0x89, 0x4a, 0x7e, 0x86, 0x46, 0x7a, 0x83,
+    0x42, 0x78, 0x80, 0x3e, 0x74, 0x7d, 0x3a, 0x72, 0x7a, 0x37, 0x6f, 0x77, 0x34, 0x6c, 0x75, 0x32, 0x69, 0x72, 0x2f, 0x67, 0x70,
+    0x2c, 0x64, 0x6d, 0x2a, 0x63, 0x6b, 0x27, 0x60, 0x69, 0x25, 0x5d, 0x66, 0x23, 0x5b, 0x64, 0x21, 0x5a, 0x62, 0x20, 0x58, 0x61,
+    0x1e, 0x56, 0x5f, 0x1c, 0x54, 0x5d, 0x19, 0x52, 0x5a, 0x18, 0x51, 0x5a, 0x17, 0x4f, 0x58, 0x17, 0x4e, 0x56, 0x16, 0x4c, 0x55,
+    0x15, 0x4a, 0x53, 0x14, 0x4a, 0x51, 0x13, 0x49, 0x51, 0x12, 0x47, 0x50, 0x11, 0x45, 0x4e, 0x11, 0x45, 0x4d, 0x10, 0x43, 0x4b,
+    0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44,
+    0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d,
+    0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36,
+    0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0xd8, 0xe5, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x33, 0x79, 0x82, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x18, 0x65, 0x70, 0x9e, 0xbf, 0xc3, 0xf9, 0xfb, 0xfb,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xdf, 0xe1, 0x49, 0x85, 0x8e,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60,
+    0x06, 0x54, 0x60, 0xcf, 0xde, 0xe0, 0xff, 0xff, 0xff, 0x44, 0x7e, 0x86, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d,
+    0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0xa6, 0xc0, 0xc4,
+    0x8e, 0xaf, 0xb4, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56,
+    0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x08, 0x4a, 0x53, 0xc5, 0xd4, 0xd7,
+    0xff, 0xff, 0xff, 0x76, 0x99, 0x9e, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b,
+    0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x4f, 0x78, 0x7e, 0xff, 0xff, 0xff, 0xe5, 0xeb, 0xec, 0x15, 0x49, 0x50,
+    0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c,
+    0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x17, 0x41, 0x47, 0xef, 0xf2, 0xf2, 0xff, 0xff, 0xff, 0x25, 0x49, 0x4e,
+    0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x69, 0x7c, 0x7f,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x8e, 0x90, 0x10, 0x2a, 0x2f, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e,
+    0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x01, 0x10, 0x13, 0x00, 0x0d, 0x0f,
+    0x0a, 0x1c, 0x1f, 0xcc, 0xd1, 0xd2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xaa, 0xc5, 0xc9, 0x81, 0xa9, 0xaf, 0x7d, 0xa5, 0xac, 0x78, 0xa2, 0xa9, 0x73, 0x9e, 0xa5,
+    0x6f, 0x9b, 0xa1, 0x6a, 0x97, 0x9e, 0x66, 0x94, 0x9c, 0x61, 0x91, 0x98, 0x5c, 0x8d, 0x95, 0x58, 0x89, 0x92, 0x54, 0x86, 0x8e,
+    0x50, 0x83, 0x8b, 0x4c, 0x80, 0x88, 0x49, 0x7d, 0x86, 0x44, 0x79, 0x82, 0x41, 0x77, 0x7f, 0x3e, 0x74, 0x7d, 0x3a, 0x72, 0x7a,
+    0x37, 0x6f, 0x77, 0x34, 0x6b, 0x75, 0x31, 0x68, 0x72, 0x2f, 0x67, 0x70, 0x2c, 0x64, 0x6d, 0x29, 0x62, 0x6b, 0x26, 0x60, 0x69,
+    0x25, 0x5d, 0x66, 0x23, 0x5b, 0x64, 0x21, 0x5a, 0x62, 0x1f, 0x57, 0x61, 0x1e, 0x56, 0x5f, 0x1c, 0x54, 0x5d, 0x19, 0x52, 0x5a,
+    0x18, 0x51, 0x5a, 0x17, 0x4f, 0x58, 0x17, 0x4e, 0x56, 0x16, 0x4c, 0x55, 0x15, 0x4a, 0x53, 0x14, 0x4a, 0x51, 0x13, 0x49, 0x51,
+    0x12, 0x47, 0x50, 0x11, 0x45, 0x4e, 0x34, 0x60, 0x67, 0x3f, 0x68, 0x6e, 0x3b, 0x65, 0x6b, 0x3b, 0x64, 0x6a, 0x3b, 0x63, 0x6a,
+    0x3b, 0x63, 0x69, 0x3b, 0x62, 0x68, 0x3b, 0x62, 0x68, 0x2b, 0x54, 0x5b, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41,
+    0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a,
+    0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30,
+    0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x6b, 0x9d, 0xa4, 0x86, 0xaf, 0xb5, 0x84, 0xae, 0xb4, 0x84, 0xae, 0xb4, 0x84, 0xae, 0xb4, 0x84, 0xae, 0xb4, 0x85, 0xaf, 0xb4,
+    0x7e, 0xaa, 0xb0, 0x1b, 0x69, 0x74, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x32, 0x76, 0x80, 0x68, 0x9a, 0xa1, 0x83, 0xac, 0xb2, 0x85, 0xae, 0xb4,
+    0x77, 0xa5, 0xab, 0x4b, 0x86, 0x8f, 0x0f, 0x5e, 0x69, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61,
+    0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x72, 0x9e, 0xa5, 0x98, 0xb9, 0xbd,
+    0x27, 0x6a, 0x73, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x0f, 0x56, 0x60, 0x36, 0x71, 0x7a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58,
+    0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54,
+    0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x1c, 0x59, 0x61, 0xa7, 0xbe, 0xc2, 0xa7, 0xbe, 0xc1, 0x1c, 0x57, 0x5f, 0x05, 0x45, 0x4e,
+    0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48,
+    0x0a, 0x43, 0x4b, 0x96, 0xae, 0xb1, 0xb3, 0xc4, 0xc7, 0x2f, 0x5e, 0x64, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41,
+    0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38,
+    0x0d, 0x39, 0x3f, 0x74, 0x8c, 0x90, 0x7c, 0x92, 0x95, 0x13, 0x3a, 0x40, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f,
+    0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x62, 0x77, 0x79, 0x86, 0x95, 0x97, 0x7e, 0x8d, 0x8f,
+    0x2e, 0x45, 0x49, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18,
+    0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x01, 0x10, 0x13, 0x00, 0x0b, 0x0d, 0x14, 0x29, 0x2c, 0xe5, 0xe7, 0xe7, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1, 0xdf, 0xe2,
+    0x7f, 0xa8, 0xae, 0x7b, 0xa4, 0xab, 0x77, 0xa1, 0xa8, 0x72, 0x9e, 0xa4, 0x6e, 0x9a, 0xa1, 0x69, 0x97, 0x9e, 0x65, 0x94, 0x9b,
+    0x5f, 0x90, 0x97, 0x5b, 0x8c, 0x95, 0x58, 0x89, 0x92, 0x53, 0x86, 0x8e, 0x4f, 0x82, 0x8b, 0x4c, 0x80, 0x88, 0x49, 0x7d, 0x86,
+    0x45, 0x7a, 0x82, 0x41, 0x77, 0x7f, 0x3d, 0x74, 0x7c, 0x3a, 0x72, 0x7a, 0x36, 0x6e, 0x76, 0x34, 0x6b, 0x75, 0x31, 0x68, 0x72,
+    0x2e, 0x66, 0x6f, 0x2c, 0x64, 0x6d, 0x29, 0x62, 0x6b, 0x26, 0x60, 0x69, 0x25, 0x5d, 0x66, 0x23, 0x5b, 0x64, 0x21, 0x5a, 0x62,
+    0x1f, 0x57, 0x61, 0x1d, 0x55, 0x5e, 0x1c, 0x54, 0x5d, 0x19, 0x52, 0x5a, 0x18, 0x51, 0x5a, 0x17, 0x4f, 0x58, 0x17, 0x4e, 0x56,
+    0x16, 0x4c, 0x55, 0x15, 0x4a, 0x53, 0x14, 0x4a, 0x51, 0x12, 0x48, 0x51, 0x12, 0x47, 0x50, 0x11, 0x45, 0x4e, 0xcc, 0xd7, 0xd9,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xae, 0xbe, 0xc1, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e,
+    0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37,
+    0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60,
+    0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e,
+    0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a,
+    0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56,
+    0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51,
+    0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c,
+    0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45,
+    0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d,
+    0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34,
+    0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a,
+    0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f,
+    0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x01, 0x10, 0x13,
+    0x00, 0x0a, 0x0c, 0x23, 0x3a, 0x3d, 0xfb, 0xfc, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf2, 0xf6, 0xf7, 0x8b, 0xb0, 0xb5, 0x7a, 0xa4, 0xaa, 0x75, 0xa0, 0xa7,
+    0x71, 0x9d, 0xa4, 0x6d, 0x99, 0xa0, 0x68, 0x96, 0x9d, 0x64, 0x92, 0x9a, 0x5f, 0x90, 0x97, 0x5a, 0x8c, 0x94, 0x57, 0x88, 0x91,
+    0x52, 0x85, 0x8d, 0x4e, 0x82, 0x8a, 0x4b, 0x7f, 0x88, 0x48, 0x7c, 0x85, 0x44, 0x79, 0x82, 0x40, 0x76, 0x7e, 0x3d, 0x74, 0x7c,
+    0x39, 0x71, 0x79, 0x36, 0x6e, 0x76, 0x33, 0x6a, 0x74, 0x31, 0x68, 0x72, 0x2e, 0x66, 0x6f, 0x2b, 0x63, 0x6c, 0x29, 0x62, 0x6b,
+    0x26, 0x5f, 0x68, 0x25, 0x5d, 0x66, 0x23, 0x5b, 0x64, 0x21, 0x5a, 0x62, 0x1f, 0x57, 0x61, 0x1d, 0x55, 0x5e, 0x1b, 0x53, 0x5c,
+    0x19, 0x52, 0x5a, 0x18, 0x51, 0x5a, 0x17, 0x4f, 0x58, 0x17, 0x4e, 0x56, 0x16, 0x4c, 0x55, 0x15, 0x4a, 0x53, 0x14, 0x4a, 0x51,
+    0x12, 0x48, 0x51, 0x12, 0x47, 0x50, 0x11, 0x45, 0x4e, 0xc9, 0xd5, 0xd7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xac, 0xbc, 0xbf, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42,
+    0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b,
+    0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34,
+    0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62,
+    0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f,
+    0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55,
+    0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f,
+    0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49,
+    0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42,
+    0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a,
+    0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30,
+    0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26,
+    0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a,
+    0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x01, 0x10, 0x13, 0x00, 0x0a, 0x0c, 0x37, 0x4f, 0x53, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xb4, 0xcc, 0xd0, 0x79, 0xa3, 0xaa, 0x74, 0x9f, 0xa6, 0x70, 0x9c, 0xa3, 0x6c, 0x99, 0xa0, 0x67, 0x96, 0x9d,
+    0x63, 0x92, 0x9a, 0x5e, 0x8f, 0x97, 0x5a, 0x8b, 0x94, 0x56, 0x88, 0x90, 0x51, 0x85, 0x8d, 0x4d, 0x81, 0x89, 0x4a, 0x7f, 0x87,
+    0x47, 0x7c, 0x84, 0x42, 0x78, 0x80, 0x3f, 0x76, 0x7e, 0x3c, 0x73, 0x7c, 0x38, 0x70, 0x79, 0x35, 0x6d, 0x76, 0x33, 0x6a, 0x74,
+    0x30, 0x68, 0x71, 0x2d, 0x65, 0x6e, 0x2a, 0x63, 0x6b, 0x28, 0x61, 0x6a, 0x26, 0x5f, 0x68, 0x24, 0x5d, 0x66, 0x21, 0x5a, 0x63,
+    0x20, 0x59, 0x61, 0x1f, 0x57, 0x61, 0x1d, 0x55, 0x5e, 0x1b, 0x53, 0x5c, 0x19, 0x52, 0x5a, 0x18, 0x51, 0x5a, 0x17, 0x4f, 0x58,
+    0x17, 0x4e, 0x56, 0x16, 0x4c, 0x55, 0x15, 0x4a, 0x53, 0x14, 0x4a, 0x51, 0x12, 0x48, 0x51, 0x12, 0x47, 0x50, 0x11, 0x45, 0x4e,
+    0xc9, 0xd5, 0xd7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xac, 0xbc, 0xbf, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f,
+    0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38,
+    0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61,
+    0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e,
+    0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b,
+    0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57,
+    0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52,
+    0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d,
+    0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46,
+    0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e,
+    0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36,
+    0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c,
+    0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21,
+    0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14,
+    0x01, 0x10, 0x12, 0x00, 0x0b, 0x0d, 0x59, 0x71, 0x75, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe9, 0xf0, 0xf1, 0x7e, 0xa6, 0xad,
+    0x73, 0x9e, 0xa6, 0x6f, 0x9b, 0xa2, 0x6a, 0x97, 0x9e, 0x66, 0x95, 0x9c, 0x62, 0x91, 0x99, 0x5d, 0x8e, 0x96, 0x59, 0x8a, 0x93,
+    0x55, 0x87, 0x90, 0x50, 0x84, 0x8c, 0x4d, 0x81, 0x89, 0x49, 0x7e, 0x86, 0x45, 0x7a, 0x83, 0x42, 0x78, 0x80, 0x3f, 0x76, 0x7e,
+    0x3b, 0x72, 0x7b, 0x38, 0x70, 0x79, 0x34, 0x6d, 0x75, 0x32, 0x6a, 0x73, 0x30, 0x68, 0x71, 0x2d, 0x65, 0x6e, 0x2a, 0x63, 0x6b,
+    0x28, 0x61, 0x6a, 0x25, 0x5e, 0x67, 0x24, 0x5d, 0x66, 0x22, 0x5a, 0x64, 0x1f, 0x58, 0x61, 0x1e, 0x57, 0x60, 0x1d, 0x55, 0x5e,
+    0x1b, 0x53, 0x5c, 0x19, 0x52, 0x5a, 0x17, 0x50, 0x59, 0x17, 0x4f, 0x57, 0x16, 0x4d, 0x56, 0x16, 0x4c, 0x55, 0x15, 0x4a, 0x53,
+    0x14, 0x4a, 0x51, 0x12, 0x48, 0x51, 0x12, 0x47, 0x50, 0x11, 0x45, 0x4e, 0xc9, 0xd5, 0xd7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xac, 0xbc, 0xbf, 0x0d, 0x3b, 0x43,
+    0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c,
+    0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35,
+    0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60,
+    0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55,
+    0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50,
+    0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a,
+    0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43,
+    0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b,
+    0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32,
+    0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27,
+    0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c,
+    0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x01, 0x10, 0x12, 0x00, 0x0d, 0x0f, 0x8e, 0x9f, 0xa2,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xae, 0xc7, 0xcb, 0x71, 0x9d, 0xa4, 0x6e, 0x9b, 0xa1, 0x69, 0x97, 0x9e,
+    0x64, 0x94, 0x9b, 0x61, 0x90, 0x98, 0x5b, 0x8d, 0x95, 0x58, 0x8a, 0x92, 0x54, 0x86, 0x8f, 0x4f, 0x83, 0x8b, 0x4c, 0x80, 0x88,
+    0x48, 0x7d, 0x86, 0x44, 0x7a, 0x82, 0x41, 0x77, 0x80, 0x3e, 0x75, 0x7d, 0x3a, 0x72, 0x7b, 0x37, 0x6f, 0x78, 0x34, 0x6d, 0x75,
+    0x32, 0x6a, 0x73, 0x2f, 0x67, 0x70, 0x2c, 0x65, 0x6e, 0x2a, 0x63, 0x6b, 0x27, 0x60, 0x6a, 0x26, 0x5f, 0x68, 0x24, 0x5d, 0x66,
+    0x22, 0x5a, 0x64, 0x20, 0x59, 0x61, 0x1e, 0x57, 0x60, 0x1c, 0x54, 0x5e, 0x1b, 0x53, 0x5c, 0x18, 0x51, 0x5a, 0x17, 0x50, 0x59,
+    0x17, 0x4f, 0x57, 0x16, 0x4d, 0x56, 0x15, 0x4b, 0x54, 0x15, 0x4a, 0x53, 0x14, 0x4a, 0x51, 0x12, 0x48, 0x51, 0x12, 0x47, 0x50,
+    0x11, 0x45, 0x4e, 0xc9, 0xd5, 0xd7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xac, 0xbc, 0xbf, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40,
+    0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39,
+    0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61,
+    0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e,
+    0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b,
+    0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57,
+    0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53,
+    0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d,
+    0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47,
+    0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f,
+    0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37,
+    0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e,
+    0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23,
+    0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16,
+    0x01, 0x12, 0x14, 0x01, 0x0f, 0x12, 0x03, 0x12, 0x14, 0xc5, 0xcf, 0xd1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xed, 0xf3, 0xf4, 0x7b, 0xa5, 0xab, 0x6c, 0x99, 0xa0, 0x67, 0x96, 0x9d, 0x64, 0x93, 0x9a, 0x5f, 0x8f, 0x97, 0x5a, 0x8c, 0x94,
+    0x57, 0x89, 0x92, 0x52, 0x85, 0x8e, 0x4e, 0x83, 0x8b, 0x4b, 0x7f, 0x88, 0x47, 0x7d, 0x85, 0x44, 0x7a, 0x82, 0x41, 0x77, 0x80,
+    0x3d, 0x74, 0x7c, 0x39, 0x71, 0x7a, 0x36, 0x6f, 0x77, 0x34, 0x6c, 0x75, 0x31, 0x69, 0x73, 0x2f, 0x67, 0x70, 0x2c, 0x65, 0x6e,
+    0x29, 0x62, 0x6b, 0x27, 0x60, 0x6a, 0x25, 0x5e, 0x67, 0x23, 0x5c, 0x65, 0x20, 0x59, 0x62, 0x1f, 0x58, 0x61, 0x1e, 0x57, 0x60,
+    0x1c, 0x54, 0x5e, 0x1a, 0x53, 0x5b, 0x18, 0x51, 0x5a, 0x17, 0x50, 0x59, 0x17, 0x4f, 0x57, 0x16, 0x4d, 0x56, 0x15, 0x4b, 0x54,
+    0x14, 0x4a, 0x52, 0x14, 0x4a, 0x51, 0x12, 0x48, 0x51, 0x11, 0x46, 0x4f, 0x11, 0x45, 0x4e, 0xc9, 0xd4, 0xd6, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xac, 0xbc, 0xbf,
+    0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d,
+    0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36,
+    0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60,
+    0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d,
+    0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56,
+    0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51,
+    0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b,
+    0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44,
+    0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c,
+    0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33,
+    0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29,
+    0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e,
+    0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x00, 0x0e, 0x0f, 0x10, 0x24, 0x27,
+    0xe8, 0xec, 0xed, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xd3, 0xd6, 0x6a, 0x98, 0x9f,
+    0x66, 0x95, 0x9c, 0x62, 0x92, 0x99, 0x5e, 0x8e, 0x97, 0x5a, 0x8c, 0x94, 0x55, 0x88, 0x90, 0x51, 0x85, 0x8d, 0x4d, 0x82, 0x8a,
+    0x4a, 0x7f, 0x87, 0x46, 0x7c, 0x84, 0x43, 0x79, 0x82, 0x40, 0x76, 0x7f, 0x3c, 0x74, 0x7c, 0x39, 0x71, 0x7a, 0x35, 0x6e, 0x77,
+    0x33, 0x6b, 0x74, 0x30, 0x68, 0x72, 0x2e, 0x66, 0x70, 0x2b, 0x64, 0x6d, 0x28, 0x61, 0x6a, 0x26, 0x60, 0x69, 0x25, 0x5e, 0x67,
+    0x23, 0x5c, 0x65, 0x21, 0x5a, 0x63, 0x1e, 0x57, 0x60, 0x1d, 0x56, 0x5f, 0x1c, 0x54, 0x5e, 0x1a, 0x53, 0x5b, 0x18, 0x51, 0x5a,
+    0x17, 0x50, 0x59, 0x17, 0x4f, 0x57, 0x16, 0x4d, 0x56, 0x15, 0x4b, 0x54, 0x14, 0x4a, 0x52, 0x14, 0x4a, 0x51, 0x12, 0x48, 0x51,
+    0x11, 0x46, 0x4f, 0x11, 0x45, 0x4e, 0xc9, 0xd4, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xac, 0xbc, 0xbf, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41,
+    0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a,
+    0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30,
+    0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61,
+    0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f,
+    0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58,
+    0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54,
+    0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e,
+    0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48,
+    0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41,
+    0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38,
+    0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f,
+    0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24,
+    0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18,
+    0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x00, 0x0b, 0x0d, 0x28, 0x41, 0x44, 0xfd, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfe, 0xfe, 0x95, 0xb6, 0xbb, 0x64, 0x94, 0x9b, 0x61, 0x91, 0x98, 0x5c, 0x8d, 0x95,
+    0x58, 0x8b, 0x92, 0x54, 0x87, 0x90, 0x50, 0x84, 0x8d, 0x4d, 0x81, 0x8a, 0x49, 0x7e, 0x86, 0x45, 0x7b, 0x84, 0x42, 0x78, 0x81,
+    0x40, 0x76, 0x7f, 0x3b, 0x73, 0x7b, 0x38, 0x70, 0x79, 0x35, 0x6e, 0x77, 0x32, 0x6b, 0x73, 0x30, 0x68, 0x72, 0x2d, 0x65, 0x6f,
+    0x2a, 0x63, 0x6c, 0x29, 0x62, 0x6b, 0x26, 0x60, 0x69, 0x23, 0x5d, 0x66, 0x22, 0x5b, 0x64, 0x20, 0x59, 0x62, 0x1f, 0x58, 0x61,
+    0x1d, 0x56, 0x5f, 0x1b, 0x53, 0x5d, 0x1a, 0x53, 0x5b, 0x18, 0x51, 0x5a, 0x17, 0x50, 0x59, 0x17, 0x4f, 0x57, 0x16, 0x4d, 0x56,
+    0x15, 0x4b, 0x54, 0x14, 0x4a, 0x52, 0x13, 0x49, 0x51, 0x12, 0x48, 0x51, 0x11, 0x46, 0x4f, 0x11, 0x45, 0x4e, 0xc9, 0xd4, 0xd6,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xac, 0xbc, 0xbf, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e,
+    0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37,
+    0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60,
+    0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e,
+    0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a,
+    0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56,
+    0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51,
+    0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c,
+    0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45,
+    0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d,
+    0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34,
+    0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a,
+    0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f,
+    0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x12, 0x14, 0x00, 0x0b, 0x0e,
+    0x50, 0x6a, 0x6e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xeb, 0xf2, 0xf3, 0xf5, 0xf8, 0xf9, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xeb, 0xf1, 0xf2, 0x75, 0x9e, 0xa5, 0x5f, 0x90, 0x97, 0x5b, 0x8c, 0x95, 0x56, 0x89, 0x91, 0x52, 0x86, 0x8f, 0x4f, 0x83, 0x8c,
+    0x4c, 0x81, 0x89, 0x48, 0x7d, 0x86, 0x44, 0x7b, 0x83, 0x40, 0x77, 0x80, 0x3e, 0x74, 0x7d, 0x3a, 0x72, 0x7b, 0x37, 0x6f, 0x79,
+    0x34, 0x6d, 0x76, 0x32, 0x6b, 0x73, 0x2f, 0x68, 0x71, 0x2c, 0x65, 0x6f, 0x2a, 0x63, 0x6c, 0x27, 0x60, 0x6a, 0x26, 0x5f, 0x68,
+    0x24, 0x5d, 0x67, 0x22, 0x5b, 0x64, 0x1f, 0x58, 0x62, 0x1e, 0x57, 0x60, 0x1d, 0x56, 0x5f, 0x1b, 0x53, 0x5d, 0x1a, 0x53, 0x5b,
+    0x18, 0x51, 0x5a, 0x17, 0x50, 0x58, 0x16, 0x4e, 0x57, 0x16, 0x4d, 0x56, 0x15, 0x4b, 0x54, 0x14, 0x4a, 0x52, 0x13, 0x49, 0x51,
+    0x12, 0x48, 0x51, 0x11, 0x46, 0x4f, 0x11, 0x45, 0x4e, 0xc9, 0xd4, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xac, 0xbc, 0xbf, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42,
+    0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b,
+    0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34,
+    0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62,
+    0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f,
+    0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55,
+    0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f,
+    0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49,
+    0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42,
+    0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a,
+    0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30,
+    0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26,
+    0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a,
+    0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x01, 0x11, 0x14, 0x00, 0x0f, 0x12, 0x9c, 0xac, 0xae, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xb5, 0xcd, 0xd1, 0xc8, 0xda, 0xdd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, 0xe2, 0xe4, 0x64, 0x93, 0x9b,
+    0x59, 0x8b, 0x94, 0x55, 0x89, 0x90, 0x51, 0x85, 0x8e, 0x4d, 0x82, 0x8b, 0x4a, 0x7f, 0x88, 0x46, 0x7c, 0x84, 0x43, 0x7a, 0x83,
+    0x40, 0x77, 0x80, 0x3d, 0x74, 0x7d, 0x39, 0x72, 0x7a, 0x36, 0x6f, 0x78, 0x34, 0x6d, 0x75, 0x31, 0x6a, 0x73, 0x2e, 0x67, 0x71,
+    0x2b, 0x64, 0x6e, 0x29, 0x63, 0x6c, 0x27, 0x60, 0x6a, 0x25, 0x5e, 0x68, 0x22, 0x5c, 0x65, 0x21, 0x5a, 0x64, 0x20, 0x59, 0x62,
+    0x1d, 0x57, 0x5f, 0x1c, 0x55, 0x5f, 0x1b, 0x53, 0x5d, 0x19, 0x52, 0x5b, 0x17, 0x50, 0x59, 0x17, 0x50, 0x58, 0x16, 0x4e, 0x57,
+    0x15, 0x4c, 0x55, 0x15, 0x4b, 0x54, 0x14, 0x4a, 0x52, 0x13, 0x49, 0x51, 0x12, 0x48, 0x51, 0x11, 0x46, 0x4f, 0x11, 0x45, 0x4e,
+    0xc9, 0xd4, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xac, 0xbc, 0xbf, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f,
+    0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38,
+    0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61,
+    0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e,
+    0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b,
+    0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57,
+    0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52,
+    0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d,
+    0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46,
+    0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e,
+    0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36,
+    0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c,
+    0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21,
+    0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x00, 0x10, 0x12,
+    0x09, 0x1c, 0x20, 0xdb, 0xe1, 0xe2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xfd, 0xfd, 0x9a, 0xbc, 0xc0, 0x90, 0xb4, 0xba,
+    0xef, 0xf4, 0xf5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7, 0xd8, 0xdb, 0x5a, 0x8c, 0x94, 0x53, 0x87, 0x8f, 0x4f, 0x84, 0x8d,
+    0x4c, 0x81, 0x8a, 0x48, 0x7e, 0x86, 0x45, 0x7b, 0x84, 0x42, 0x79, 0x82, 0x3f, 0x76, 0x7f, 0x3c, 0x73, 0x7c, 0x38, 0x71, 0x79,
+    0x35, 0x6e, 0x77, 0x33, 0x6c, 0x75, 0x30, 0x69, 0x72, 0x2d, 0x66, 0x70, 0x2b, 0x64, 0x6e, 0x28, 0x62, 0x6b, 0x26, 0x60, 0x69,
+    0x25, 0x5e, 0x68, 0x23, 0x5d, 0x66, 0x21, 0x5a, 0x64, 0x1f, 0x58, 0x62, 0x1d, 0x57, 0x5f, 0x1c, 0x55, 0x5f, 0x1a, 0x53, 0x5c,
+    0x19, 0x52, 0x5b, 0x17, 0x50, 0x59, 0x17, 0x50, 0x58, 0x16, 0x4e, 0x57, 0x15, 0x4c, 0x55, 0x14, 0x4b, 0x53, 0x14, 0x4a, 0x52,
+    0x13, 0x49, 0x51, 0x11, 0x47, 0x50, 0x11, 0x46, 0x4f, 0x11, 0x45, 0x4e, 0xc9, 0xd4, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xac, 0xbc, 0xbf, 0x0d, 0x3b, 0x43,
+    0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c,
+    0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35,
+    0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60,
+    0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55,
+    0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50,
+    0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a,
+    0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43,
+    0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b,
+    0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32,
+    0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27,
+    0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c,
+    0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x02, 0x13, 0x16, 0x00, 0x0d, 0x0f, 0x27, 0x3f, 0x44, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xe4, 0xed, 0xee, 0x8a, 0xb1, 0xb7, 0x85, 0xad, 0xb3, 0xab, 0xc6, 0xca, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xc1, 0xd4, 0xd7, 0x56, 0x89, 0x91, 0x4d, 0x83, 0x8c, 0x4b, 0x80, 0x89, 0x47, 0x7d, 0x86, 0x44, 0x7b, 0x83,
+    0x40, 0x78, 0x81, 0x3e, 0x75, 0x7e, 0x3b, 0x72, 0x7b, 0x37, 0x70, 0x79, 0x34, 0x6d, 0x77, 0x32, 0x6b, 0x74, 0x2f, 0x69, 0x71,
+    0x2c, 0x66, 0x6f, 0x2a, 0x63, 0x6d, 0x27, 0x61, 0x6a, 0x26, 0x5f, 0x68, 0x24, 0x5e, 0x67, 0x21, 0x5b, 0x65, 0x20, 0x5a, 0x63,
+    0x1e, 0x57, 0x61, 0x1d, 0x57, 0x5f, 0x1b, 0x54, 0x5e, 0x1a, 0x53, 0x5c, 0x19, 0x52, 0x5b, 0x17, 0x50, 0x59, 0x17, 0x50, 0x58,
+    0x16, 0x4e, 0x57, 0x15, 0x4c, 0x55, 0x14, 0x4b, 0x53, 0x14, 0x4a, 0x52, 0x13, 0x49, 0x51, 0x11, 0x47, 0x50, 0x11, 0x46, 0x4f,
+    0x10, 0x44, 0x4d, 0xc9, 0xd4, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xac, 0xbc, 0xbf, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40,
+    0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39,
+    0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61,
+    0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e,
+    0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b,
+    0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57,
+    0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53,
+    0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d,
+    0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47,
+    0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f,
+    0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37,
+    0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e,
+    0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23,
+    0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x01, 0x13, 0x16,
+    0x00, 0x0e, 0x10, 0x5d, 0x75, 0x79, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc6, 0xd9, 0xdc, 0x86, 0xae, 0xb4,
+    0x83, 0xab, 0xb2, 0x7f, 0xa8, 0xaf, 0xc6, 0xd8, 0xdb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc8, 0xd9, 0xdc,
+    0x59, 0x8a, 0x93, 0x49, 0x7f, 0x88, 0x46, 0x7d, 0x85, 0x42, 0x79, 0x82, 0x40, 0x77, 0x80, 0x3d, 0x74, 0x7e, 0x39, 0x71, 0x7a,
+    0x35, 0x6f, 0x77, 0x34, 0x6d, 0x76, 0x31, 0x6b, 0x73, 0x2e, 0x68, 0x71, 0x2c, 0x66, 0x6f, 0x2a, 0x63, 0x6d, 0x27, 0x61, 0x6a,
+    0x25, 0x5e, 0x68, 0x24, 0x5e, 0x67, 0x21, 0x5b, 0x65, 0x20, 0x5a, 0x63, 0x1e, 0x57, 0x61, 0x1c, 0x56, 0x5f, 0x1b, 0x54, 0x5e,
+    0x1a, 0x53, 0x5c, 0x18, 0x51, 0x5a, 0x17, 0x50, 0x58, 0x16, 0x4f, 0x58, 0x16, 0x4e, 0x57, 0x15, 0x4c, 0x55, 0x14, 0x4b, 0x53,
+    0x13, 0x49, 0x52, 0x13, 0x49, 0x51, 0x11, 0x47, 0x50, 0x11, 0x46, 0x4f, 0x10, 0x44, 0x4d, 0xc8, 0xd4, 0xd6, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xac, 0xbc, 0xbf,
+    0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d,
+    0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36,
+    0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60,
+    0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d,
+    0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56,
+    0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51,
+    0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b,
+    0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44,
+    0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c,
+    0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33,
+    0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29,
+    0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e,
+    0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x01, 0x12, 0x15, 0x03, 0x14, 0x17, 0xbb, 0xc8, 0xc9, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0xc0, 0xc4, 0x84, 0xac, 0xb2, 0x80, 0xa9, 0xb0, 0x7c, 0xa6, 0xad, 0x7d, 0xa8, 0xae,
+    0xda, 0xe6, 0xe8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdd, 0xe7, 0xe9, 0x68, 0x94, 0x9d, 0x44, 0x7b, 0x84,
+    0x41, 0x79, 0x81, 0x3f, 0x77, 0x80, 0x3b, 0x73, 0x7c, 0x38, 0x70, 0x7a, 0x34, 0x6e, 0x77, 0x32, 0x6b, 0x75, 0x30, 0x6a, 0x73,
+    0x2d, 0x67, 0x70, 0x2a, 0x64, 0x6e, 0x28, 0x62, 0x6c, 0x26, 0x61, 0x6a, 0x25, 0x5e, 0x68, 0x23, 0x5d, 0x66, 0x20, 0x5b, 0x64,
+    0x1f, 0x59, 0x62, 0x1d, 0x57, 0x60, 0x1c, 0x56, 0x5f, 0x1a, 0x54, 0x5d, 0x19, 0x52, 0x5c, 0x18, 0x51, 0x5a, 0x17, 0x50, 0x58,
+    0x16, 0x4f, 0x58, 0x15, 0x4d, 0x56, 0x15, 0x4c, 0x55, 0x14, 0x4b, 0x53, 0x13, 0x49, 0x52, 0x13, 0x49, 0x51, 0x11, 0x47, 0x50,
+    0x11, 0x46, 0x4f, 0x2d, 0x5b, 0x63, 0xe2, 0xe8, 0xe9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xac, 0xbc, 0xbf, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41,
+    0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a,
+    0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30,
+    0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61,
+    0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f,
+    0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58,
+    0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54,
+    0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e,
+    0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48,
+    0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41,
+    0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38,
+    0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f,
+    0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24,
+    0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18,
+    0x00, 0x0f, 0x11, 0x1a, 0x32, 0x36, 0xf8, 0xfa, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe6, 0xef, 0xf0, 0x87, 0xaf, 0xb5,
+    0x81, 0xaa, 0xb1, 0x7d, 0xa8, 0xae, 0x79, 0xa5, 0xab, 0x76, 0xa2, 0xa9, 0x81, 0xa9, 0xaf, 0xe8, 0xef, 0xf0, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xf7, 0xf7, 0x91, 0xb2, 0xb7, 0x42, 0x79, 0x81, 0x3d, 0x75, 0x7e, 0x3a, 0x72, 0x7c,
+    0x37, 0x70, 0x79, 0x34, 0x6e, 0x76, 0x31, 0x6b, 0x74, 0x2e, 0x69, 0x72, 0x2c, 0x67, 0x6f, 0x2a, 0x64, 0x6e, 0x28, 0x62, 0x6c,
+    0x26, 0x60, 0x69, 0x24, 0x5e, 0x67, 0x22, 0x5c, 0x66, 0x20, 0x5b, 0x64, 0x1e, 0x58, 0x62, 0x1d, 0x57, 0x60, 0x1b, 0x55, 0x5e,
+    0x1a, 0x54, 0x5d, 0x19, 0x52, 0x5c, 0x18, 0x51, 0x5a, 0x17, 0x50, 0x58, 0x16, 0x4f, 0x58, 0x15, 0x4d, 0x56, 0x14, 0x4c, 0x54,
+    0x14, 0x4b, 0x53, 0x13, 0x49, 0x52, 0x12, 0x48, 0x50, 0x11, 0x47, 0x50, 0x61, 0x84, 0x8a, 0xe5, 0xea, 0xeb, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xac, 0xbc, 0xbf, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e,
+    0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37,
+    0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60,
+    0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e,
+    0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a,
+    0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56,
+    0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51,
+    0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c,
+    0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45,
+    0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d,
+    0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34,
+    0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a,
+    0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f,
+    0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x02, 0x15, 0x18, 0x00, 0x0e, 0x11, 0x53, 0x6c, 0x70, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc1, 0xd6, 0xd9, 0x82, 0xab, 0xb2, 0x7e, 0xa8, 0xaf, 0x7a, 0xa6, 0xad, 0x77, 0xa3, 0xaa,
+    0x73, 0xa0, 0xa7, 0x6f, 0x9d, 0xa4, 0x85, 0xac, 0xb2, 0xed, 0xf3, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xcd, 0xdb, 0xde, 0x66, 0x93, 0x9a, 0x39, 0x72, 0x7b, 0x36, 0x6f, 0x78, 0x33, 0x6d, 0x76, 0x30, 0x6a, 0x74,
+    0x2d, 0x68, 0x71, 0x2b, 0x66, 0x6f, 0x28, 0x63, 0x6d, 0x27, 0x61, 0x6b, 0x26, 0x61, 0x6a, 0x24, 0x5e, 0x67, 0x22, 0x5c, 0x66,
+    0x20, 0x5b, 0x64, 0x1e, 0x58, 0x62, 0x1c, 0x56, 0x60, 0x1b, 0x55, 0x5e, 0x1a, 0x54, 0x5d, 0x18, 0x51, 0x5b, 0x17, 0x51, 0x59,
+    0x17, 0x50, 0x58, 0x16, 0x4f, 0x58, 0x15, 0x4d, 0x56, 0x14, 0x4c, 0x54, 0x13, 0x4a, 0x53, 0x13, 0x49, 0x52, 0x3a, 0x67, 0x6e,
+    0xb2, 0xc4, 0xc7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xac, 0xbc, 0xbf, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42,
+    0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b,
+    0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34,
+    0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62,
+    0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f,
+    0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55,
+    0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f,
+    0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49,
+    0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42,
+    0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a,
+    0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30,
+    0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26,
+    0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a,
+    0x01, 0x14, 0x17, 0x03, 0x15, 0x19, 0xb8, 0xc4, 0xc6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfc, 0xfd, 0x97, 0xba, 0xbf,
+    0x7e, 0xa9, 0xaf, 0x7a, 0xa6, 0xad, 0x78, 0xa4, 0xab, 0x74, 0xa1, 0xa8, 0x70, 0x9e, 0xa6, 0x6c, 0x9b, 0xa3, 0x69, 0x99, 0xa0,
+    0x81, 0xa9, 0xb0, 0xec, 0xf2, 0xf3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfc, 0xfc,
+    0xb9, 0xcd, 0xd1, 0x5f, 0x8d, 0x94, 0x33, 0x6d, 0x76, 0x2f, 0x69, 0x73, 0x2c, 0x67, 0x70, 0x2a, 0x65, 0x6e, 0x27, 0x62, 0x6c,
+    0x26, 0x60, 0x6a, 0x24, 0x5f, 0x68, 0x23, 0x5d, 0x66, 0x21, 0x5c, 0x65, 0x1f, 0x5a, 0x63, 0x1d, 0x58, 0x61, 0x1c, 0x56, 0x60,
+    0x1b, 0x55, 0x5e, 0x19, 0x53, 0x5d, 0x18, 0x51, 0x5b, 0x17, 0x51, 0x59, 0x16, 0x4f, 0x58, 0x15, 0x4e, 0x57, 0x15, 0x4d, 0x56,
+    0x14, 0x4c, 0x54, 0x40, 0x6d, 0x74, 0xa4, 0xb9, 0xbd, 0xf7, 0xf9, 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xae, 0xbe, 0xc1, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f,
+    0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38,
+    0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61,
+    0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e,
+    0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b,
+    0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57,
+    0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52,
+    0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d,
+    0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46,
+    0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e,
+    0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36,
+    0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c,
+    0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21,
+    0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x02, 0x17, 0x1a, 0x00, 0x10, 0x13, 0x1f, 0x39, 0x3d, 0xfe, 0xfe, 0xfe,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, 0xe7, 0xe9, 0x7e, 0xa9, 0xb0, 0x7b, 0xa7, 0xae, 0x78, 0xa4, 0xab, 0x74, 0xa1, 0xa9,
+    0x71, 0x9f, 0xa6, 0x6d, 0x9c, 0xa4, 0x6a, 0x99, 0xa1, 0x66, 0x97, 0x9f, 0x63, 0x94, 0x9c, 0x79, 0xa4, 0xa9, 0xe4, 0xed, 0xee,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xfd, 0xfd, 0xc9, 0xd8, 0xda,
+    0x81, 0xa4, 0xaa, 0x42, 0x78, 0x80, 0x29, 0x65, 0x6e, 0x27, 0x62, 0x6c, 0x25, 0x5f, 0x69, 0x24, 0x5f, 0x68, 0x23, 0x5d, 0x66,
+    0x20, 0x5b, 0x64, 0x1e, 0x59, 0x63, 0x1d, 0x58, 0x61, 0x1b, 0x55, 0x5f, 0x1a, 0x55, 0x5d, 0x19, 0x53, 0x5d, 0x18, 0x51, 0x5b,
+    0x17, 0x51, 0x59, 0x17, 0x50, 0x59, 0x31, 0x63, 0x6b, 0x70, 0x93, 0x98, 0xbe, 0xce, 0xd0, 0xfa, 0xfb, 0xfc, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb4, 0xc3, 0xc5, 0x54, 0x75, 0x7b, 0x0d, 0x3b, 0x43,
+    0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c,
+    0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35,
+    0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60,
+    0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55,
+    0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50,
+    0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a,
+    0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43,
+    0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b,
+    0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32,
+    0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27,
+    0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c,
+    0x02, 0x16, 0x1a, 0x00, 0x10, 0x13, 0x6a, 0x82, 0x85, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xaa, 0xc6, 0xcb,
+    0x7a, 0xa7, 0xae, 0x78, 0xa4, 0xab, 0x75, 0xa2, 0xa9, 0x71, 0xa0, 0xa7, 0x6e, 0x9d, 0xa4, 0x6b, 0x9b, 0xa2, 0x68, 0x98, 0xa0,
+    0x64, 0x96, 0x9d, 0x60, 0x92, 0x9a, 0x5d, 0x91, 0x98, 0x69, 0x98, 0xa0, 0xd1, 0xdf, 0xe2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0xf7, 0xf8, 0xc8, 0xd7, 0xda,
+    0x98, 0xb5, 0xb9, 0x72, 0x97, 0x9e, 0x52, 0x80, 0x87, 0x3b, 0x6f, 0x77, 0x2d, 0x65, 0x6d, 0x29, 0x61, 0x6a, 0x27, 0x5f, 0x68,
+    0x29, 0x60, 0x69, 0x39, 0x6c, 0x73, 0x4f, 0x7b, 0x83, 0x6e, 0x92, 0x98, 0x95, 0xb0, 0xb3, 0xc7, 0xd5, 0xd7, 0xf4, 0xf7, 0xf7,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0x9d, 0xb1, 0xb4, 0x13, 0x42, 0x49, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40,
+    0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39,
+    0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61,
+    0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e,
+    0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b,
+    0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57,
+    0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53,
+    0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d,
+    0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47,
+    0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f,
+    0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37,
+    0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e,
+    0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23,
+    0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x02, 0x18, 0x1c, 0x00, 0x14, 0x18, 0x0a, 0x21, 0x25, 0xdb, 0xe1, 0xe3,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe9, 0xf0, 0xf1, 0x80, 0xab, 0xb1, 0x78, 0xa5, 0xac, 0x74, 0xa2, 0xa9, 0x71, 0xa0, 0xa7,
+    0x6e, 0x9e, 0xa5, 0x6b, 0x9b, 0xa2, 0x67, 0x98, 0xa0, 0x65, 0x96, 0x9e, 0x61, 0x94, 0x9b, 0x5d, 0x91, 0x99, 0x5a, 0x8f, 0x96,
+    0x57, 0x8b, 0x94, 0x58, 0x8c, 0x94, 0xae, 0xc7, 0xcb, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xfc, 0xfd,
+    0xf5, 0xf7, 0xf8, 0xee, 0xf3, 0xf3, 0xea, 0xef, 0xf0, 0xea, 0xef, 0xf0, 0xf0, 0xf4, 0xf4, 0xf5, 0xf8, 0xf8, 0xfd, 0xfe, 0xfe,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0xfb, 0xfb, 0x7b, 0x96, 0x9a, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44,
+    0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d,
+    0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36,
+    0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60,
+    0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d,
+    0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56,
+    0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51,
+    0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b,
+    0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44,
+    0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c,
+    0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33,
+    0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29,
+    0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e,
+    0x02, 0x18, 0x1c, 0x00, 0x11, 0x14, 0x40, 0x5c, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb5, 0xce, 0xd2,
+    0x77, 0xa4, 0xab, 0x74, 0xa3, 0xaa, 0x71, 0xa0, 0xa7, 0x6e, 0x9e, 0xa5, 0x6b, 0x9b, 0xa3, 0x68, 0x99, 0xa0, 0x65, 0x97, 0x9f,
+    0x61, 0x94, 0x9c, 0x5e, 0x92, 0x99, 0x5b, 0x8f, 0x98, 0x57, 0x8d, 0x95, 0x54, 0x89, 0x92, 0x51, 0x87, 0x90, 0x4e, 0x85, 0x8d,
+    0x7e, 0xa5, 0xac, 0xe4, 0xed, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdb, 0xe3, 0xe4, 0x4a, 0x6f, 0x75,
+    0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41,
+    0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a,
+    0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30,
+    0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61,
+    0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f,
+    0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58,
+    0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54,
+    0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e,
+    0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48,
+    0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41,
+    0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38,
+    0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f,
+    0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24,
+    0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x1a, 0x1e, 0x00, 0x17, 0x1b, 0x03, 0x19, 0x1c, 0xae, 0xbd, 0xbf,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf5, 0xf6, 0x81, 0xab, 0xb2, 0x73, 0xa2, 0xa9, 0x70, 0xa0, 0xa7, 0x6d, 0x9e, 0xa5,
+    0x6b, 0x9b, 0xa3, 0x68, 0x99, 0xa1, 0x64, 0x96, 0x9e, 0x62, 0x95, 0x9d, 0x5f, 0x92, 0x9a, 0x5b, 0x90, 0x98, 0x58, 0x8d, 0x96,
+    0x55, 0x8b, 0x93, 0x52, 0x88, 0x91, 0x4e, 0x85, 0x8e, 0x4c, 0x84, 0x8c, 0x49, 0x80, 0x89, 0x54, 0x88, 0x90, 0xac, 0xc5, 0xc9,
+    0xfa, 0xfb, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xfb, 0xfc, 0xfc, 0x9a, 0xaf, 0xb3, 0x1e, 0x4d, 0x55, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45,
+    0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e,
+    0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37,
+    0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60,
+    0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e,
+    0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a,
+    0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56,
+    0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51,
+    0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c,
+    0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45,
+    0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d,
+    0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34,
+    0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a,
+    0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f,
+    0x02, 0x1a, 0x1e, 0x00, 0x13, 0x16, 0x29, 0x46, 0x4b, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb9, 0xd1, 0xd5,
+    0x72, 0xa1, 0xa9, 0x6f, 0xa0, 0xa7, 0x6c, 0x9e, 0xa5, 0x6a, 0x9b, 0xa3, 0x67, 0x99, 0xa1, 0x64, 0x97, 0x9f, 0x61, 0x94, 0x9c,
+    0x5f, 0x93, 0x9b, 0x5c, 0x90, 0x98, 0x58, 0x8e, 0x96, 0x56, 0x8b, 0x94, 0x52, 0x89, 0x91, 0x4f, 0x86, 0x8f, 0x4c, 0x84, 0x8d,
+    0x4a, 0x82, 0x8a, 0x47, 0x7f, 0x88, 0x44, 0x7d, 0x86, 0x41, 0x7a, 0x84, 0x66, 0x94, 0x9b, 0xc9, 0xd9, 0xdc, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc2, 0xcf, 0xd1, 0x47, 0x6e, 0x75, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48,
+    0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42,
+    0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b,
+    0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34,
+    0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62,
+    0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f,
+    0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55,
+    0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f,
+    0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49,
+    0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42,
+    0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a,
+    0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30,
+    0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26,
+    0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1b, 0x1f, 0x02, 0x19, 0x1d, 0x01, 0x18, 0x1b, 0x96, 0xa9, 0xac,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xf5, 0xf5, 0x7e, 0xaa, 0xb1, 0x6e, 0x9f, 0xa7, 0x6c, 0x9d, 0xa5, 0x69, 0x9b, 0xa3,
+    0x66, 0x99, 0xa1, 0x64, 0x97, 0x9f, 0x61, 0x95, 0x9d, 0x5e, 0x92, 0x9a, 0x5c, 0x91, 0x99, 0x59, 0x8e, 0x97, 0x56, 0x8c, 0x94,
+    0x53, 0x8a, 0x92, 0x50, 0x88, 0x90, 0x4d, 0x85, 0x8e, 0x4a, 0x82, 0x8b, 0x48, 0x80, 0x89, 0x45, 0x7e, 0x86, 0x42, 0x7c, 0x85,
+    0x3f, 0x79, 0x83, 0x3c, 0x77, 0x80, 0x3a, 0x75, 0x7f, 0x73, 0x9c, 0xa3, 0xcd, 0xdc, 0xde, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xc4, 0xd1, 0xd3, 0x58, 0x7d, 0x83,
+    0x11, 0x45, 0x4d, 0x0f, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45,
+    0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f,
+    0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38,
+    0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61,
+    0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e,
+    0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b,
+    0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57,
+    0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52,
+    0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d,
+    0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46,
+    0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e,
+    0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36,
+    0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c,
+    0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21,
+    0x02, 0x1b, 0x1f, 0x00, 0x14, 0x18, 0x23, 0x40, 0x45, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb3, 0xcd, 0xd1,
+    0x6d, 0x9f, 0xa6, 0x6b, 0x9d, 0xa5, 0x69, 0x9b, 0xa3, 0x66, 0x99, 0xa1, 0x63, 0x97, 0x9f, 0x60, 0x94, 0x9d, 0x5e, 0x93, 0x9b,
+    0x5c, 0x91, 0x99, 0x59, 0x8f, 0x97, 0x56, 0x8c, 0x95, 0x53, 0x8a, 0x92, 0x50, 0x88, 0x91, 0x4d, 0x86, 0x8e, 0x4b, 0x83, 0x8c,
+    0x48, 0x80, 0x8a, 0x45, 0x7f, 0x87, 0x42, 0x7c, 0x85, 0x3f, 0x7a, 0x83, 0x3e, 0x78, 0x82, 0x3a, 0x76, 0x7f, 0x37, 0x73, 0x7d,
+    0x35, 0x71, 0x7b, 0x35, 0x70, 0x79, 0x66, 0x92, 0x99, 0xb4, 0xca, 0xcd, 0xf1, 0xf5, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xec, 0xf1, 0xf1,
+    0xa4, 0xb9, 0xbc, 0x4a, 0x73, 0x7a, 0x12, 0x46, 0x4f, 0x0f, 0x44, 0x4d, 0x0f, 0x44, 0x4c, 0x0f, 0x43, 0x4b, 0x0e, 0x41, 0x49,
+    0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43,
+    0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c,
+    0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35,
+    0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60,
+    0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55,
+    0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50,
+    0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a,
+    0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43,
+    0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b,
+    0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32,
+    0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27,
+    0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x02, 0x1d, 0x21, 0x02, 0x1a, 0x1e, 0x01, 0x18, 0x1c, 0x94, 0xa7, 0xaa,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe8, 0xf0, 0xf1, 0x74, 0xa3, 0xab, 0x6a, 0x9d, 0xa4, 0x67, 0x9a, 0xa2, 0x65, 0x99, 0xa1,
+    0x62, 0x97, 0x9f, 0x60, 0x94, 0x9d, 0x5d, 0x92, 0x9a, 0x5b, 0x91, 0x99, 0x58, 0x8e, 0x97, 0x55, 0x8c, 0x95, 0x54, 0x8a, 0x93,
+    0x50, 0x88, 0x91, 0x4d, 0x86, 0x8f, 0x4b, 0x84, 0x8c, 0x48, 0x81, 0x8b, 0x45, 0x7f, 0x88, 0x43, 0x7d, 0x86, 0x40, 0x7b, 0x83,
+    0x3e, 0x79, 0x82, 0x3b, 0x76, 0x80, 0x38, 0x75, 0x7e, 0x35, 0x72, 0x7c, 0x33, 0x70, 0x7a, 0x32, 0x6e, 0x78, 0x2f, 0x6b, 0x75,
+    0x2d, 0x6a, 0x74, 0x40, 0x77, 0x80, 0x7b, 0xa1, 0xa7, 0xb6, 0xcb, 0xce, 0xe6, 0xed, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe,
+    0xde, 0xe6, 0xe7, 0xa9, 0xbd, 0xc0, 0x65, 0x89, 0x8e, 0x25, 0x56, 0x5e, 0x11, 0x47, 0x4f, 0x10, 0x46, 0x4f, 0x0f, 0x45, 0x4e,
+    0x0f, 0x44, 0x4d, 0x0f, 0x44, 0x4c, 0x0f, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46,
+    0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40,
+    0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39,
+    0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61,
+    0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e,
+    0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b,
+    0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57,
+    0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53,
+    0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d,
+    0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47,
+    0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f,
+    0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37,
+    0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e,
+    0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23,
+    0x02, 0x1d, 0x21, 0x00, 0x16, 0x19, 0x29, 0x47, 0x4c, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa0, 0xc1, 0xc6,
+    0x69, 0x9c, 0xa4, 0x66, 0x9a, 0xa2, 0x63, 0x98, 0xa0, 0x61, 0x96, 0x9e, 0x5f, 0x95, 0x9d, 0x5c, 0x92, 0x9a, 0x5a, 0x90, 0x99,
+    0x57, 0x8e, 0x97, 0x55, 0x8c, 0x95, 0x53, 0x8a, 0x93, 0x50, 0x88, 0x91, 0x4d, 0x87, 0x8f, 0x4b, 0x84, 0x8d, 0x48, 0x82, 0x8b,
+    0x45, 0x7f, 0x89, 0x43, 0x7d, 0x87, 0x40, 0x7b, 0x84, 0x3e, 0x79, 0x82, 0x3c, 0x77, 0x80, 0x39, 0x75, 0x7f, 0x36, 0x73, 0x7d,
+    0x33, 0x70, 0x7b, 0x32, 0x6e, 0x79, 0x30, 0x6d, 0x77, 0x2e, 0x6b, 0x74, 0x2c, 0x69, 0x73, 0x2a, 0x67, 0x71, 0x27, 0x64, 0x6e,
+    0x26, 0x64, 0x6d, 0x31, 0x6a, 0x75, 0x52, 0x83, 0x8a, 0x7e, 0xa2, 0xa7, 0xa2, 0xbc, 0xc0, 0xbc, 0xce, 0xd1, 0xd0, 0xdd, 0xdf,
+    0xdf, 0xe7, 0xe9, 0xe9, 0xef, 0xf0, 0xec, 0xf1, 0xf2, 0xeb, 0xf0, 0xf1, 0xe6, 0xed, 0xee, 0xdb, 0xe4, 0xe5, 0xca, 0xd7, 0xd9,
+    0xb4, 0xc6, 0xca, 0x97, 0xb1, 0xb5, 0x6e, 0x91, 0x97, 0x3e, 0x6e, 0x75, 0x1d, 0x53, 0x5c, 0x12, 0x4a, 0x53, 0x12, 0x49, 0x52,
+    0x11, 0x47, 0x50, 0x11, 0x47, 0x4f, 0x10, 0x46, 0x4f, 0x0f, 0x45, 0x4e, 0x0f, 0x44, 0x4d, 0x0f, 0x44, 0x4c, 0x0f, 0x43, 0x4b,
+    0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44,
+    0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d,
+    0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36,
+    0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60,
+    0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d,
+    0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56,
+    0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51,
+    0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b,
+    0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44,
+    0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c,
+    0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33,
+    0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29,
+    0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x02, 0x1e, 0x23, 0x01, 0x1b, 0x1f, 0x03, 0x1d, 0x21, 0xa6, 0xb6, 0xb9,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd6, 0xe4, 0xe7, 0x68, 0x9b, 0xa3, 0x65, 0x9a, 0xa1, 0x62, 0x98, 0xa0, 0x60, 0x96, 0x9f,
+    0x5e, 0x94, 0x9c, 0x5b, 0x92, 0x9a, 0x59, 0x90, 0x99, 0x56, 0x8e, 0x96, 0x55, 0x8c, 0x95, 0x52, 0x8a, 0x93, 0x50, 0x89, 0x91,
+    0x4d, 0x86, 0x8f, 0x4b, 0x85, 0x8d, 0x48, 0x82, 0x8b, 0x45, 0x80, 0x89, 0x43, 0x7e, 0x88, 0x40, 0x7b, 0x85, 0x3e, 0x7a, 0x83,
+    0x3c, 0x77, 0x80, 0x3a, 0x76, 0x7f, 0x37, 0x73, 0x7d, 0x34, 0x72, 0x7b, 0x33, 0x70, 0x7a, 0x30, 0x6d, 0x77, 0x2e, 0x6c, 0x75,
+    0x2c, 0x69, 0x73, 0x2a, 0x68, 0x72, 0x28, 0x66, 0x70, 0x26, 0x64, 0x6e, 0x25, 0x63, 0x6c, 0x23, 0x61, 0x6b, 0x22, 0x60, 0x69,
+    0x20, 0x5e, 0x67, 0x1f, 0x5c, 0x67, 0x1e, 0x5b, 0x65, 0x21, 0x5d, 0x67, 0x28, 0x62, 0x6a, 0x2c, 0x64, 0x6c, 0x2b, 0x63, 0x6c,
+    0x2a, 0x62, 0x6a, 0x27, 0x5f, 0x68, 0x21, 0x59, 0x62, 0x1a, 0x53, 0x5d, 0x15, 0x4f, 0x58, 0x15, 0x4f, 0x57, 0x13, 0x4d, 0x56,
+    0x13, 0x4d, 0x56, 0x12, 0x4b, 0x54, 0x12, 0x4a, 0x53, 0x11, 0x48, 0x51, 0x11, 0x47, 0x50, 0x11, 0x47, 0x4f, 0x0f, 0x46, 0x4f,
+    0x0f, 0x45, 0x4e, 0x0f, 0x44, 0x4d, 0x0f, 0x44, 0x4c, 0x0f, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47,
+    0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41,
+    0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a,
+    0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30,
+    0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61,
+    0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f,
+    0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58,
+    0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54,
+    0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e,
+    0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48,
+    0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41,
+    0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38,
+    0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f,
+    0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24,
+    0x02, 0x1e, 0x23, 0x00, 0x17, 0x1a, 0x3d, 0x5b, 0x5f, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xfb, 0xfb, 0x86, 0xaf, 0xb6,
+    0x63, 0x98, 0xa1, 0x61, 0x97, 0x9f, 0x5f, 0x95, 0x9d, 0x5d, 0x93, 0x9c, 0x5a, 0x91, 0x9a, 0x58, 0x90, 0x99, 0x55, 0x8e, 0x96,
+    0x54, 0x8c, 0x95, 0x51, 0x8a, 0x93, 0x4f, 0x88, 0x91, 0x4d, 0x87, 0x90, 0x4a, 0x84, 0x8d, 0x48, 0x83, 0x8b, 0x45, 0x80, 0x8a,
+    0x43, 0x7f, 0x88, 0x40, 0x7c, 0x86, 0x3e, 0x7a, 0x84, 0x3c, 0x78, 0x81, 0x3a, 0x76, 0x7f, 0x37, 0x74, 0x7d, 0x35, 0x72, 0x7c,
+    0x33, 0x71, 0x7a, 0x31, 0x6e, 0x79, 0x2f, 0x6c, 0x77, 0x2d, 0x6b, 0x75, 0x2b, 0x69, 0x73, 0x29, 0x67, 0x71, 0x27, 0x65, 0x6f,
+    0x26, 0x63, 0x6d, 0x24, 0x62, 0x6c, 0x22, 0x60, 0x6a, 0x21, 0x5f, 0x69, 0x1f, 0x5d, 0x67, 0x1e, 0x5b, 0x66, 0x1d, 0x5a, 0x64,
+    0x1c, 0x59, 0x63, 0x1a, 0x57, 0x60, 0x19, 0x56, 0x60, 0x17, 0x55, 0x5e, 0x17, 0x54, 0x5d, 0x17, 0x52, 0x5c, 0x16, 0x51, 0x5a,
+    0x16, 0x50, 0x5a, 0x15, 0x4f, 0x58, 0x14, 0x4e, 0x57, 0x13, 0x4d, 0x56, 0x12, 0x4c, 0x55, 0x12, 0x4b, 0x54, 0x12, 0x4a, 0x53,
+    0x11, 0x48, 0x51, 0x11, 0x47, 0x50, 0x11, 0x47, 0x4f, 0x0f, 0x46, 0x4f, 0x0f, 0x45, 0x4e, 0x0f, 0x44, 0x4d, 0x0f, 0x44, 0x4c,
+    0x0f, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45,
+    0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e,
+    0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37,
+    0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60,
+    0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e,
+    0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a,
+    0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56,
+    0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51,
+    0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c,
+    0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45,
+    0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d,
+    0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34,
+    0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a,
+    0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x02, 0x20, 0x24, 0x00, 0x1b, 0x1f, 0x0b, 0x28, 0x2c, 0xca, 0xd5, 0xd6,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb1, 0xcc, 0xd1, 0x61, 0x98, 0xa0, 0x5f, 0x96, 0x9f, 0x5d, 0x95, 0x9d, 0x5b, 0x93, 0x9b,
+    0x59, 0x91, 0x9a, 0x57, 0x90, 0x98, 0x55, 0x8e, 0x97, 0x53, 0x8c, 0x95, 0x51, 0x8a, 0x93, 0x4e, 0x88, 0x91, 0x4c, 0x86, 0x8f,
+    0x4a, 0x85, 0x8e, 0x48, 0x82, 0x8c, 0x45, 0x81, 0x8a, 0x42, 0x7e, 0x88, 0x40, 0x7d, 0x86, 0x3e, 0x7a, 0x84, 0x3c, 0x78, 0x82,
+    0x3a, 0x77, 0x80, 0x38, 0x75, 0x7e, 0x35, 0x73, 0x7c, 0x33, 0x71, 0x7b, 0x31, 0x6f, 0x79, 0x2f, 0x6d, 0x78, 0x2d, 0x6b, 0x76,
+    0x2b, 0x6a, 0x74, 0x29, 0x67, 0x71, 0x27, 0x66, 0x70, 0x26, 0x65, 0x6f, 0x25, 0x62, 0x6c, 0x22, 0x61, 0x6a, 0x21, 0x5f, 0x6a,
+    0x20, 0x5f, 0x68, 0x1f, 0x5d, 0x67, 0x1d, 0x5b, 0x65, 0x1c, 0x59, 0x64, 0x1b, 0x59, 0x62, 0x1a, 0x57, 0x60, 0x19, 0x56, 0x60,
+    0x17, 0x55, 0x5e, 0x17, 0x53, 0x5d, 0x17, 0x52, 0x5c, 0x16, 0x51, 0x5a, 0x15, 0x50, 0x59, 0x15, 0x4f, 0x58, 0x14, 0x4e, 0x57,
+    0x13, 0x4d, 0x56, 0x12, 0x4c, 0x55, 0x12, 0x4b, 0x54, 0x11, 0x49, 0x52, 0x11, 0x48, 0x51, 0x11, 0x47, 0x50, 0x11, 0x47, 0x4f,
+    0x0f, 0x46, 0x4f, 0x0f, 0x45, 0x4e, 0x0f, 0x44, 0x4d, 0x0f, 0x44, 0x4c, 0x0f, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48,
+    0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42,
+    0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b,
+    0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34,
+    0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62,
+    0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f,
+    0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55,
+    0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f,
+    0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49,
+    0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42,
+    0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a,
+    0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30,
+    0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26,
+    0x02, 0x1f, 0x24, 0x00, 0x19, 0x1d, 0x6a, 0x83, 0x87, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdd, 0xe9, 0xeb, 0x64, 0x9a, 0xa2,
+    0x5d, 0x95, 0x9e, 0x5c, 0x94, 0x9d, 0x5a, 0x92, 0x9b, 0x57, 0x90, 0x99, 0x55, 0x8e, 0x98, 0x55, 0x8e, 0x97, 0x52, 0x8c, 0x95,
+    0x4f, 0x89, 0x92, 0x4d, 0x87, 0x90, 0x4b, 0x86, 0x8f, 0x49, 0x84, 0x8d, 0x48, 0x83, 0x8c, 0x45, 0x80, 0x8a, 0x42, 0x7f, 0x88,
+    0x3f, 0x7c, 0x86, 0x3e, 0x7b, 0x84, 0x3c, 0x79, 0x83, 0x3a, 0x77, 0x81, 0x37, 0x75, 0x7e, 0x35, 0x73, 0x7c, 0x33, 0x72, 0x7b,
+    0x32, 0x6f, 0x7a, 0x2f, 0x6e, 0x78, 0x2d, 0x6c, 0x77, 0x2b, 0x6a, 0x74, 0x29, 0x68, 0x72, 0x28, 0x67, 0x71, 0x26, 0x65, 0x70,
+    0x25, 0x63, 0x6d, 0x24, 0x62, 0x6c, 0x21, 0x60, 0x6a, 0x20, 0x5f, 0x69, 0x1f, 0x5e, 0x67, 0x1e, 0x5c, 0x66, 0x1c, 0x5a, 0x65,
+    0x1b, 0x59, 0x63, 0x1a, 0x58, 0x61, 0x19, 0x56, 0x60, 0x19, 0x56, 0x60, 0x17, 0x54, 0x5e, 0x17, 0x53, 0x5d, 0x16, 0x51, 0x5b,
+    0x16, 0x51, 0x5a, 0x15, 0x50, 0x59, 0x14, 0x4e, 0x58, 0x14, 0x4e, 0x57, 0x12, 0x4c, 0x55, 0x12, 0x4c, 0x55, 0x12, 0x4b, 0x54,
+    0x11, 0x49, 0x52, 0x11, 0x48, 0x51, 0x11, 0x47, 0x50, 0x10, 0x47, 0x4f, 0x0f, 0x46, 0x4f, 0x0f, 0x45, 0x4e, 0x0f, 0x44, 0x4d,
+    0x0f, 0x44, 0x4c, 0x0f, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45,
+    0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f,
+    0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38,
+    0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61,
+    0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e,
+    0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b,
+    0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57,
+    0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52,
+    0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d,
+    0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46,
+    0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e,
+    0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36,
+    0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c,
+    0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27, 0x02, 0x21, 0x26, 0x00, 0x1a, 0x1e, 0x22, 0x42, 0x47, 0xf9, 0xfb, 0xfb,
+    0xff, 0xff, 0xff, 0xf7, 0xfa, 0xfa, 0x81, 0xad, 0xb4, 0x5c, 0x94, 0x9d, 0x5b, 0x94, 0x9c, 0x59, 0x92, 0x9b, 0x57, 0x90, 0x99,
+    0x55, 0x8f, 0x97, 0x52, 0x8c, 0x96, 0x50, 0x8b, 0x94, 0x4f, 0x8a, 0x93, 0x4c, 0x88, 0x91, 0x4a, 0x86, 0x8f, 0x49, 0x84, 0x8e,
+    0x47, 0x82, 0x8c, 0x44, 0x80, 0x8a, 0x42, 0x7e, 0x88, 0x3f, 0x7d, 0x86, 0x3e, 0x7b, 0x85, 0x3b, 0x79, 0x82, 0x39, 0x77, 0x81,
+    0x37, 0x75, 0x7f, 0x35, 0x74, 0x7d, 0x33, 0x72, 0x7b, 0x32, 0x70, 0x7a, 0x30, 0x6e, 0x79, 0x2d, 0x6d, 0x77, 0x2b, 0x6b, 0x75,
+    0x2a, 0x69, 0x74, 0x28, 0x68, 0x72, 0x26, 0x65, 0x70, 0x26, 0x65, 0x6f, 0x24, 0x63, 0x6d, 0x23, 0x61, 0x6b, 0x20, 0x60, 0x69,
+    0x1f, 0x5e, 0x68, 0x1e, 0x5d, 0x67, 0x1d, 0x5c, 0x65, 0x1c, 0x5a, 0x65, 0x1a, 0x58, 0x62, 0x19, 0x57, 0x61, 0x18, 0x55, 0x5f,
+    0x18, 0x55, 0x5f, 0x17, 0x54, 0x5e, 0x16, 0x52, 0x5c, 0x16, 0x51, 0x5b, 0x15, 0x50, 0x59, 0x15, 0x50, 0x59, 0x14, 0x4e, 0x58,
+    0x14, 0x4e, 0x57, 0x12, 0x4c, 0x55, 0x12, 0x4c, 0x55, 0x11, 0x4a, 0x53, 0x11, 0x49, 0x52, 0x11, 0x48, 0x51, 0x11, 0x47, 0x50,
+    0x10, 0x47, 0x4f, 0x0f, 0x46, 0x4f, 0x0f, 0x45, 0x4e, 0x0f, 0x44, 0x4d, 0x0f, 0x44, 0x4c, 0x0f, 0x43, 0x4b, 0x0e, 0x41, 0x49,
+    0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43,
+    0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c,
+    0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35,
+    0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60,
+    0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55,
+    0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50,
+    0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a,
+    0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43,
+    0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b,
+    0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32,
+    0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x23, 0x27,
+    0x00, 0x1f, 0x24, 0x05, 0x24, 0x29, 0xae, 0xbe, 0xc1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa4, 0xc4, 0xc9, 0x5a, 0x93, 0x9c,
+    0x58, 0x92, 0x9b, 0x57, 0x91, 0x9a, 0x55, 0x8f, 0x99, 0x52, 0x8d, 0x96, 0x50, 0x8c, 0x94, 0x4f, 0x8a, 0x94, 0x4d, 0x89, 0x92,
+    0x4b, 0x88, 0x91, 0x49, 0x86, 0x8f, 0x48, 0x84, 0x8d, 0x46, 0x82, 0x8c, 0x43, 0x80, 0x89, 0x41, 0x7f, 0x88, 0x3f, 0x7c, 0x86,
+    0x3d, 0x7b, 0x84, 0x3b, 0x79, 0x83, 0x39, 0x78, 0x81, 0x37, 0x76, 0x80, 0x35, 0x74, 0x7e, 0x33, 0x72, 0x7c, 0x32, 0x70, 0x7a,
+    0x30, 0x6f, 0x79, 0x2e, 0x6d, 0x77, 0x2c, 0x6c, 0x76, 0x2a, 0x6a, 0x75, 0x28, 0x68, 0x73, 0x26, 0x66, 0x70, 0x26, 0x65, 0x6f,
+    0x24, 0x64, 0x6e, 0x23, 0x62, 0x6c, 0x22, 0x60, 0x6b, 0x1f, 0x5f, 0x68, 0x1e, 0x5d, 0x68, 0x1d, 0x5d, 0x66, 0x1c, 0x5b, 0x65,
+    0x1b, 0x59, 0x64, 0x1a, 0x58, 0x62, 0x19, 0x57, 0x61, 0x18, 0x55, 0x5f, 0x18, 0x55, 0x5f, 0x17, 0x54, 0x5e, 0x16, 0x52, 0x5c,
+    0x15, 0x50, 0x5a, 0x15, 0x50, 0x59, 0x14, 0x4f, 0x59, 0x14, 0x4e, 0x58, 0x13, 0x4d, 0x56, 0x12, 0x4c, 0x55, 0x12, 0x4c, 0x55,
+    0x11, 0x4a, 0x53, 0x11, 0x49, 0x52, 0x11, 0x48, 0x51, 0x10, 0x47, 0x50, 0x10, 0x47, 0x4f, 0x0f, 0x46, 0x4f, 0x0f, 0x45, 0x4e,
+    0x0f, 0x44, 0x4d, 0x0f, 0x44, 0x4c, 0x0f, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46,
+    0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40,
+    0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39,
+    0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61,
+    0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e,
+    0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b,
+    0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57,
+    0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53,
+    0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d,
+    0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47,
+    0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f,
+    0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37,
+    0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e,
+    0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29, 0x02, 0x22, 0x27, 0x00, 0x1b, 0x20, 0x5e, 0x7a, 0x7e, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xc7, 0xdb, 0xde, 0x57, 0x92, 0x9b, 0x55, 0x90, 0x99, 0x54, 0x8f, 0x99, 0x53, 0x8f, 0x98, 0x52, 0x8d, 0x96,
+    0x50, 0x8c, 0x95, 0x4d, 0x8a, 0x93, 0x4c, 0x88, 0x92, 0x4a, 0x87, 0x90, 0x49, 0x86, 0x8f, 0x47, 0x84, 0x8d, 0x45, 0x82, 0x8b,
+    0x42, 0x80, 0x8a, 0x40, 0x7e, 0x88, 0x3e, 0x7d, 0x87, 0x3d, 0x7b, 0x85, 0x3b, 0x7a, 0x83, 0x39, 0x78, 0x82, 0x37, 0x77, 0x80,
+    0x35, 0x75, 0x7f, 0x33, 0x72, 0x7d, 0x32, 0x71, 0x7b, 0x30, 0x6f, 0x79, 0x2e, 0x6e, 0x77, 0x2d, 0x6c, 0x77, 0x2a, 0x6b, 0x75,
+    0x28, 0x69, 0x73, 0x27, 0x67, 0x72, 0x26, 0x66, 0x70, 0x25, 0x64, 0x6e, 0x23, 0x63, 0x6d, 0x22, 0x61, 0x6c, 0x20, 0x5f, 0x69,
+    0x1e, 0x5e, 0x68, 0x1d, 0x5d, 0x67, 0x1c, 0x5c, 0x66, 0x1b, 0x5a, 0x64, 0x1a, 0x59, 0x63, 0x19, 0x57, 0x62, 0x19, 0x57, 0x61,
+    0x18, 0x55, 0x5f, 0x18, 0x55, 0x5f, 0x16, 0x53, 0x5d, 0x16, 0x52, 0x5c, 0x15, 0x50, 0x5a, 0x14, 0x50, 0x59, 0x14, 0x4f, 0x59,
+    0x13, 0x4d, 0x57, 0x13, 0x4d, 0x56, 0x12, 0x4c, 0x55, 0x11, 0x4b, 0x54, 0x11, 0x4a, 0x53, 0x11, 0x49, 0x52, 0x11, 0x48, 0x51,
+    0x10, 0x47, 0x50, 0x10, 0x47, 0x4f, 0x0f, 0x46, 0x4f, 0x0f, 0x45, 0x4e, 0x0f, 0x44, 0x4d, 0x0f, 0x44, 0x4c, 0x0e, 0x42, 0x4a,
+    0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44,
+    0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d,
+    0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36,
+    0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60,
+    0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d,
+    0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56,
+    0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51,
+    0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b,
+    0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44,
+    0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c,
+    0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33,
+    0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2a, 0x03, 0x24, 0x29,
+    0x00, 0x1c, 0x21, 0x27, 0x48, 0x4e, 0xf9, 0xfb, 0xfb, 0xff, 0xff, 0xff, 0xe2, 0xec, 0xee, 0x64, 0x9a, 0xa4, 0x53, 0x90, 0x98,
+    0x52, 0x8e, 0x97, 0x51, 0x8d, 0x97, 0x50, 0x8c, 0x95, 0x4e, 0x8a, 0x94, 0x4c, 0x89, 0x92, 0x4a, 0x88, 0x91, 0x49, 0x86, 0x90,
+    0x47, 0x85, 0x8e, 0x45, 0x83, 0x8d, 0x43, 0x81, 0x8b, 0x41, 0x7f, 0x89, 0x3f, 0x7e, 0x88, 0x3d, 0x7c, 0x86, 0x3d, 0x7b, 0x85,
+    0x3b, 0x79, 0x83, 0x38, 0x78, 0x81, 0x36, 0x76, 0x80, 0x34, 0x75, 0x7e, 0x32, 0x73, 0x7d, 0x32, 0x71, 0x7c, 0x30, 0x70, 0x79,
+    0x2e, 0x6e, 0x77, 0x2c, 0x6c, 0x76, 0x2b, 0x6b, 0x76, 0x28, 0x6a, 0x73, 0x27, 0x68, 0x73, 0x26, 0x66, 0x71, 0x25, 0x65, 0x6f,
+    0x23, 0x63, 0x6d, 0x22, 0x62, 0x6c, 0x21, 0x61, 0x6b, 0x1f, 0x5e, 0x69, 0x1d, 0x5e, 0x67, 0x1c, 0x5c, 0x67, 0x1b, 0x5b, 0x65,
+    0x1a, 0x5a, 0x63, 0x19, 0x58, 0x63, 0x18, 0x56, 0x61, 0x18, 0x56, 0x60, 0x18, 0x55, 0x5f, 0x17, 0x54, 0x5e, 0x16, 0x53, 0x5d,
+    0x15, 0x51, 0x5b, 0x15, 0x50, 0x5a, 0x14, 0x50, 0x59, 0x14, 0x4f, 0x59, 0x13, 0x4d, 0x57, 0x13, 0x4d, 0x56, 0x11, 0x4b, 0x54,
+    0x11, 0x4b, 0x54, 0x11, 0x4a, 0x53, 0x11, 0x49, 0x52, 0x10, 0x48, 0x51, 0x10, 0x47, 0x50, 0x10, 0x47, 0x4f, 0x0f, 0x46, 0x4f,
+    0x0f, 0x45, 0x4e, 0x0f, 0x44, 0x4d, 0x0e, 0x43, 0x4b, 0x0e, 0x42, 0x4a, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47,
+    0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41,
+    0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a,
+    0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30,
+    0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61,
+    0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f,
+    0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58,
+    0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54,
+    0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e,
+    0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48,
+    0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41,
+    0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38,
+    0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f,
+    0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x03, 0x25, 0x2b, 0x00, 0x20, 0x25, 0x0d, 0x2d, 0x33, 0xc3, 0xd0, 0xd2, 0xff, 0xff, 0xff,
+    0xf3, 0xf8, 0xf8, 0x76, 0xa5, 0xad, 0x51, 0x8e, 0x97, 0x50, 0x8d, 0x96, 0x4e, 0x8b, 0x95, 0x4d, 0x8b, 0x94, 0x4c, 0x8a, 0x93,
+    0x4a, 0x88, 0x92, 0x49, 0x87, 0x91, 0x47, 0x85, 0x8f, 0x45, 0x83, 0x8e, 0x44, 0x83, 0x8c, 0x42, 0x82, 0x8b, 0x40, 0x80, 0x89,
+    0x3f, 0x7e, 0x88, 0x3d, 0x7c, 0x86, 0x3c, 0x7b, 0x85, 0x3a, 0x7a, 0x84, 0x38, 0x77, 0x82, 0x35, 0x76, 0x80, 0x34, 0x75, 0x7f,
+    0x32, 0x73, 0x7d, 0x31, 0x71, 0x7c, 0x30, 0x70, 0x7a, 0x2e, 0x6f, 0x78, 0x2c, 0x6c, 0x76, 0x2b, 0x6c, 0x76, 0x29, 0x6a, 0x74,
+    0x27, 0x69, 0x73, 0x26, 0x67, 0x72, 0x25, 0x65, 0x70, 0x23, 0x64, 0x6e, 0x22, 0x62, 0x6c, 0x21, 0x62, 0x6c, 0x20, 0x60, 0x6a,
+    0x1e, 0x5e, 0x68, 0x1c, 0x5d, 0x67, 0x1b, 0x5b, 0x66, 0x1a, 0x5b, 0x64, 0x19, 0x59, 0x63, 0x19, 0x58, 0x63, 0x18, 0x56, 0x61,
+    0x18, 0x56, 0x60, 0x17, 0x54, 0x5e, 0x17, 0x54, 0x5e, 0x15, 0x52, 0x5c, 0x15, 0x51, 0x5b, 0x14, 0x50, 0x5a, 0x14, 0x50, 0x59,
+    0x13, 0x4e, 0x58, 0x13, 0x4d, 0x57, 0x13, 0x4d, 0x56, 0x11, 0x4b, 0x54, 0x11, 0x4b, 0x54, 0x11, 0x4a, 0x53, 0x10, 0x49, 0x52,
+    0x10, 0x48, 0x51, 0x10, 0x47, 0x50, 0x10, 0x47, 0x4f, 0x0f, 0x46, 0x4f, 0x0f, 0x45, 0x4e, 0x0f, 0x44, 0x4d, 0x0e, 0x43, 0x4b,
+    0x0e, 0x42, 0x4a, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45,
+    0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e,
+    0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37,
+    0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60,
+    0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e,
+    0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a,
+    0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56,
+    0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51,
+    0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c,
+    0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45,
+    0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d,
+    0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34,
+    0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x03, 0x27, 0x2c, 0x01, 0x24, 0x29,
+    0x01, 0x22, 0x27, 0x89, 0x9f, 0xa3, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0x8b, 0xb4, 0xba, 0x4e, 0x8c, 0x96, 0x4d, 0x8b, 0x95,
+    0x4c, 0x8b, 0x94, 0x4b, 0x89, 0x93, 0x49, 0x88, 0x92, 0x48, 0x88, 0x91, 0x47, 0x86, 0x90, 0x46, 0x85, 0x8f, 0x44, 0x84, 0x8d,
+    0x42, 0x82, 0x8c, 0x40, 0x80, 0x8a, 0x3f, 0x80, 0x8a, 0x3d, 0x7e, 0x88, 0x3c, 0x7c, 0x86, 0x3b, 0x7b, 0x85, 0x39, 0x79, 0x83,
+    0x37, 0x78, 0x82, 0x36, 0x76, 0x80, 0x33, 0x75, 0x7e, 0x32, 0x73, 0x7d, 0x31, 0x72, 0x7c, 0x2f, 0x70, 0x7b, 0x2e, 0x6f, 0x79,
+    0x2c, 0x6d, 0x77, 0x2a, 0x6b, 0x75, 0x29, 0x6a, 0x74, 0x27, 0x68, 0x73, 0x26, 0x68, 0x72, 0x25, 0x66, 0x71, 0x23, 0x64, 0x6f,
+    0x22, 0x63, 0x6d, 0x21, 0x62, 0x6c, 0x20, 0x61, 0x6b, 0x1f, 0x5f, 0x6a, 0x1e, 0x5e, 0x68, 0x1b, 0x5c, 0x66, 0x1a, 0x5b, 0x65,
+    0x1a, 0x5b, 0x64, 0x19, 0x59, 0x63, 0x18, 0x57, 0x62, 0x18, 0x56, 0x61, 0x17, 0x55, 0x5f, 0x17, 0x54, 0x5e, 0x17, 0x54, 0x5e,
+    0x15, 0x52, 0x5c, 0x14, 0x51, 0x5b, 0x14, 0x50, 0x5a, 0x13, 0x4f, 0x58, 0x13, 0x4e, 0x58, 0x13, 0x4d, 0x57, 0x12, 0x4c, 0x55,
+    0x11, 0x4b, 0x54, 0x11, 0x4b, 0x54, 0x11, 0x4a, 0x53, 0x10, 0x49, 0x52, 0x10, 0x48, 0x51, 0x10, 0x47, 0x50, 0x10, 0x47, 0x4f,
+    0x0f, 0x46, 0x4f, 0x0f, 0x45, 0x4e, 0x0e, 0x43, 0x4c, 0x0e, 0x43, 0x4b, 0x0e, 0x42, 0x4a, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48,
+    0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42,
+    0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b,
+    0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34,
+    0x09, 0x2a, 0x30, 0x19, 0x3f, 0x46, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62,
+    0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f,
+    0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55,
+    0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f,
+    0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49,
+    0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42,
+    0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a,
+    0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30,
+    0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x02, 0x26, 0x2c, 0x00, 0x1f, 0x24, 0x56, 0x73, 0x78, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0x9d, 0xc0, 0xc6, 0x4b, 0x8b, 0x95, 0x4a, 0x8a, 0x94, 0x49, 0x89, 0x93, 0x48, 0x88, 0x92, 0x47, 0x87, 0x91, 0x47, 0x86, 0x91,
+    0x45, 0x85, 0x8f, 0x44, 0x84, 0x8e, 0x43, 0x83, 0x8d, 0x41, 0x82, 0x8b, 0x3f, 0x80, 0x8a, 0x3e, 0x7f, 0x89, 0x3d, 0x7e, 0x88,
+    0x3b, 0x7c, 0x86, 0x3a, 0x7a, 0x84, 0x38, 0x79, 0x83, 0x37, 0x78, 0x82, 0x35, 0x76, 0x81, 0x33, 0x74, 0x7f, 0x32, 0x74, 0x7d,
+    0x30, 0x72, 0x7c, 0x2f, 0x71, 0x7b, 0x2d, 0x6f, 0x79, 0x2c, 0x6d, 0x78, 0x2a, 0x6c, 0x76, 0x29, 0x6a, 0x74, 0x27, 0x69, 0x73,
+    0x26, 0x68, 0x73, 0x25, 0x67, 0x71, 0x23, 0x65, 0x70, 0x22, 0x63, 0x6e, 0x21, 0x62, 0x6d, 0x20, 0x61, 0x6b, 0x1f, 0x60, 0x6b,
+    0x1e, 0x5f, 0x69, 0x1d, 0x5d, 0x67, 0x1b, 0x5c, 0x66, 0x1a, 0x5b, 0x65, 0x19, 0x5a, 0x64, 0x18, 0x58, 0x62, 0x18, 0x57, 0x61,
+    0x18, 0x56, 0x60, 0x17, 0x55, 0x5f, 0x16, 0x53, 0x5d, 0x16, 0x53, 0x5d, 0x15, 0x52, 0x5c, 0x14, 0x51, 0x5b, 0x14, 0x50, 0x5a,
+    0x13, 0x4f, 0x58, 0x13, 0x4e, 0x58, 0x12, 0x4c, 0x56, 0x12, 0x4c, 0x55, 0x11, 0x4b, 0x54, 0x11, 0x4b, 0x54, 0x10, 0x4a, 0x53,
+    0x10, 0x49, 0x52, 0x10, 0x48, 0x51, 0x10, 0x47, 0x50, 0x10, 0x47, 0x4f, 0x0f, 0x46, 0x4f, 0x0f, 0x45, 0x4e, 0x0e, 0x43, 0x4c,
+    0x0e, 0x43, 0x4b, 0x0e, 0x42, 0x4a, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45,
+    0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f,
+    0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38,
+    0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x30, 0x19, 0x3f, 0x45, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x07, 0x5e, 0x6a, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63,
+    0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61,
+    0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e,
+    0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b,
+    0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57,
+    0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52,
+    0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d,
+    0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46,
+    0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e,
+    0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36,
+    0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x03, 0x28, 0x2e, 0x00, 0x1f, 0x25,
+    0x32, 0x55, 0x5a, 0xfa, 0xfc, 0xfc, 0xff, 0xff, 0xff, 0xaa, 0xc8, 0xcd, 0x48, 0x8a, 0x94, 0x47, 0x89, 0x93, 0x47, 0x88, 0x92,
+    0x47, 0x87, 0x91, 0x46, 0x87, 0x90, 0x44, 0x85, 0x8f, 0x43, 0x84, 0x8e, 0x42, 0x83, 0x8d, 0x41, 0x82, 0x8d, 0x3f, 0x81, 0x8b,
+    0x3d, 0x7f, 0x89, 0x3d, 0x7e, 0x89, 0x3b, 0x7d, 0x87, 0x3a, 0x7c, 0x86, 0x38, 0x7a, 0x84, 0x37, 0x79, 0x83, 0x36, 0x78, 0x82,
+    0x34, 0x76, 0x80, 0x32, 0x75, 0x7f, 0x31, 0x73, 0x7e, 0x2f, 0x72, 0x7c, 0x2e, 0x70, 0x7b, 0x2d, 0x70, 0x79, 0x2b, 0x6e, 0x78,
+    0x2a, 0x6c, 0x77, 0x28, 0x6b, 0x75, 0x27, 0x69, 0x73, 0x26, 0x69, 0x73, 0x25, 0x66, 0x71, 0x23, 0x66, 0x70, 0x22, 0x64, 0x6f,
+    0x21, 0x62, 0x6e, 0x20, 0x62, 0x6c, 0x1f, 0x60, 0x6b, 0x1e, 0x60, 0x6a, 0x1d, 0x5e, 0x68, 0x1c, 0x5c, 0x67, 0x1a, 0x5c, 0x65,
+    0x19, 0x5a, 0x65, 0x18, 0x59, 0x63, 0x18, 0x58, 0x61, 0x18, 0x57, 0x61, 0x17, 0x55, 0x60, 0x17, 0x55, 0x5f, 0x16, 0x53, 0x5d,
+    0x15, 0x53, 0x5d, 0x14, 0x52, 0x5c, 0x14, 0x51, 0x5b, 0x13, 0x4f, 0x59, 0x13, 0x4f, 0x58, 0x13, 0x4e, 0x58, 0x12, 0x4c, 0x56,
+    0x12, 0x4c, 0x55, 0x11, 0x4b, 0x54, 0x10, 0x4b, 0x54, 0x10, 0x4a, 0x53, 0x10, 0x49, 0x52, 0x10, 0x48, 0x51, 0x10, 0x47, 0x50,
+    0x10, 0x47, 0x4f, 0x0f, 0x46, 0x4f, 0x0e, 0x44, 0x4d, 0x0e, 0x43, 0x4c, 0x0e, 0x43, 0x4b, 0x0e, 0x42, 0x4a, 0x0e, 0x41, 0x49,
+    0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43,
+    0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c,
+    0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35,
+    0x0a, 0x2e, 0x34, 0x09, 0x2a, 0x2f, 0x1b, 0x42, 0x48, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x11, 0x64, 0x70,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60,
+    0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d,
+    0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55,
+    0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50,
+    0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a,
+    0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43,
+    0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b,
+    0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32,
+    0x03, 0x2a, 0x30, 0x03, 0x29, 0x2f, 0x00, 0x22, 0x27, 0x1c, 0x41, 0x46, 0xde, 0xe5, 0xe6, 0xff, 0xff, 0xff, 0xb3, 0xce, 0xd2,
+    0x46, 0x88, 0x92, 0x45, 0x88, 0x92, 0x45, 0x87, 0x91, 0x43, 0x85, 0x8f, 0x43, 0x85, 0x8f, 0x42, 0x84, 0x8e, 0x41, 0x83, 0x8d,
+    0x40, 0x82, 0x8d, 0x3f, 0x82, 0x8b, 0x3d, 0x80, 0x8a, 0x3c, 0x7f, 0x89, 0x3b, 0x7e, 0x88, 0x3a, 0x7c, 0x87, 0x38, 0x7b, 0x85,
+    0x37, 0x7a, 0x84, 0x36, 0x79, 0x83, 0x34, 0x77, 0x81, 0x33, 0x76, 0x80, 0x31, 0x74, 0x7e, 0x31, 0x73, 0x7e, 0x30, 0x72, 0x7c,
+    0x2d, 0x71, 0x7a, 0x2c, 0x6f, 0x7a, 0x2b, 0x6e, 0x78, 0x29, 0x6c, 0x77, 0x28, 0x6b, 0x76, 0x27, 0x6a, 0x74, 0x26, 0x68, 0x72,
+    0x25, 0x67, 0x71, 0x24, 0x66, 0x71, 0x22, 0x65, 0x6f, 0x21, 0x63, 0x6f, 0x20, 0x62, 0x6d, 0x1f, 0x61, 0x6c, 0x1e, 0x60, 0x6a,
+    0x1d, 0x5f, 0x69, 0x1c, 0x5d, 0x68, 0x1b, 0x5c, 0x66, 0x19, 0x5b, 0x65, 0x18, 0x59, 0x64, 0x18, 0x59, 0x63, 0x18, 0x58, 0x61,
+    0x17, 0x56, 0x61, 0x17, 0x55, 0x60, 0x16, 0x54, 0x5e, 0x16, 0x53, 0x5d, 0x15, 0x53, 0x5d, 0x14, 0x52, 0x5c, 0x13, 0x50, 0x5a,
+    0x13, 0x4f, 0x59, 0x13, 0x4f, 0x58, 0x12, 0x4d, 0x57, 0x12, 0x4c, 0x56, 0x12, 0x4c, 0x55, 0x11, 0x4b, 0x54, 0x10, 0x4b, 0x54,
+    0x10, 0x4a, 0x53, 0x10, 0x49, 0x52, 0x10, 0x48, 0x51, 0x10, 0x47, 0x50, 0x10, 0x47, 0x4f, 0x0f, 0x46, 0x4f, 0x0e, 0x44, 0x4d,
+    0x0e, 0x43, 0x4c, 0x0e, 0x43, 0x4b, 0x0e, 0x42, 0x4a, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46,
+    0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40,
+    0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39,
+    0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2f, 0x35, 0x0a, 0x2e, 0x34, 0x09, 0x28, 0x2d, 0x2b, 0x4f, 0x55,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x37, 0x6d, 0x76, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63,
+    0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61,
+    0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e,
+    0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b,
+    0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57,
+    0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53,
+    0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d,
+    0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47,
+    0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f,
+    0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c, 0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37,
+    0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2b, 0x31, 0x00, 0x24, 0x2a, 0x12, 0x36, 0x3b,
+    0xc7, 0xd4, 0xd6, 0xff, 0xff, 0xff, 0xb6, 0xd0, 0xd5, 0x47, 0x88, 0x93, 0x43, 0x86, 0x90, 0x41, 0x85, 0x90, 0x41, 0x84, 0x8f,
+    0x40, 0x83, 0x8e, 0x3f, 0x82, 0x8d, 0x3f, 0x82, 0x8c, 0x3e, 0x81, 0x8c, 0x3c, 0x80, 0x8b, 0x3c, 0x7f, 0x89, 0x3b, 0x7e, 0x89,
+    0x3a, 0x7d, 0x87, 0x38, 0x7c, 0x86, 0x37, 0x7a, 0x85, 0x36, 0x7a, 0x84, 0x34, 0x78, 0x83, 0x33, 0x77, 0x81, 0x32, 0x75, 0x80,
+    0x31, 0x74, 0x7f, 0x30, 0x73, 0x7d, 0x2f, 0x72, 0x7d, 0x2d, 0x70, 0x7b, 0x2b, 0x6f, 0x79, 0x2a, 0x6e, 0x79, 0x29, 0x6d, 0x77,
+    0x27, 0x6b, 0x76, 0x26, 0x69, 0x74, 0x26, 0x69, 0x73, 0x25, 0x67, 0x71, 0x24, 0x67, 0x71, 0x23, 0x65, 0x70, 0x20, 0x64, 0x6e,
+    0x1f, 0x62, 0x6d, 0x1e, 0x61, 0x6c, 0x1e, 0x61, 0x6b, 0x1d, 0x5f, 0x69, 0x1c, 0x5e, 0x69, 0x1b, 0x5d, 0x67, 0x1a, 0x5b, 0x66,
+    0x18, 0x5a, 0x64, 0x18, 0x59, 0x64, 0x18, 0x59, 0x62, 0x17, 0x57, 0x61, 0x17, 0x56, 0x61, 0x16, 0x54, 0x5f, 0x16, 0x54, 0x5e,
+    0x15, 0x53, 0x5d, 0x15, 0x53, 0x5d, 0x14, 0x52, 0x5c, 0x13, 0x50, 0x5a, 0x13, 0x4f, 0x59, 0x12, 0x4e, 0x57, 0x12, 0x4d, 0x57,
+    0x12, 0x4c, 0x56, 0x12, 0x4c, 0x55, 0x10, 0x4b, 0x54, 0x10, 0x4b, 0x54, 0x10, 0x4a, 0x53, 0x10, 0x49, 0x52, 0x10, 0x48, 0x51,
+    0x10, 0x47, 0x50, 0x10, 0x47, 0x4f, 0x0e, 0x45, 0x4e, 0x0e, 0x44, 0x4d, 0x0e, 0x43, 0x4c, 0x0e, 0x43, 0x4b, 0x0e, 0x42, 0x4a,
+    0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47, 0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44,
+    0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41, 0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d,
+    0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a, 0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36,
+    0x0a, 0x30, 0x36, 0x0a, 0x2d, 0x32, 0x0a, 0x2e, 0x34, 0x56, 0x68, 0x6b, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x73, 0x75, 0x75, 0x19, 0x67, 0x72, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64,
+    0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62,
+    0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61, 0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60,
+    0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5e, 0x06, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x52, 0x5d,
+    0x05, 0x52, 0x5d, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b, 0x05, 0x50, 0x5b, 0x05, 0x50, 0x5a, 0x05, 0x4f, 0x5a,
+    0x05, 0x4e, 0x59, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57, 0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4c, 0x56,
+    0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53, 0x05, 0x48, 0x52, 0x05, 0x48, 0x51, 0x05, 0x47, 0x51,
+    0x05, 0x47, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d, 0x05, 0x43, 0x4d, 0x04, 0x43, 0x4c, 0x04, 0x42, 0x4b,
+    0x04, 0x41, 0x4a, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47, 0x04, 0x3e, 0x46, 0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44,
+    0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x3f, 0x04, 0x37, 0x3e, 0x04, 0x36, 0x3d, 0x04, 0x35, 0x3c,
+    0x04, 0x33, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x37, 0x03, 0x2f, 0x36, 0x03, 0x2e, 0x34, 0x03, 0x2d, 0x33,
+    0x03, 0x2c, 0x32, 0x00, 0x26, 0x2c, 0x0b, 0x31, 0x37, 0xad, 0xbf, 0xc2, 0xff, 0xff, 0xff, 0xb4, 0xcf, 0xd4, 0x44, 0x87, 0x92,
+    0x40, 0x84, 0x8f, 0x40, 0x84, 0x8f, 0x3e, 0x83, 0x8e, 0x3d, 0x82, 0x8d, 0x3d, 0x81, 0x8c, 0x3c, 0x81, 0x8b, 0x3c, 0x80, 0x8a,
+    0x3b, 0x7f, 0x8a, 0x3a, 0x7e, 0x89, 0x39, 0x7d, 0x88, 0x38, 0x7c, 0x87, 0x37, 0x7b, 0x86, 0x35, 0x7a, 0x84, 0x34, 0x78, 0x84,
+    0x33, 0x78, 0x82, 0x32, 0x77, 0x82, 0x31, 0x76, 0x80, 0x30, 0x74, 0x7e, 0x2f, 0x73, 0x7e, 0x2e, 0x71, 0x7c, 0x2d, 0x71, 0x7c,
+    0x2b, 0x6f, 0x7a, 0x29, 0x6e, 0x78, 0x28, 0x6d, 0x77, 0x27, 0x6c, 0x76, 0x26, 0x6a, 0x75, 0x26, 0x69, 0x74, 0x24, 0x68, 0x72,
+    0x23, 0x66, 0x70, 0x22, 0x65, 0x70, 0x21, 0x64, 0x6f, 0x1f, 0x63, 0x6d, 0x1e, 0x61, 0x6d, 0x1d, 0x60, 0x6b, 0x1c, 0x5f, 0x6a,
+    0x1c, 0x5e, 0x69, 0x1b, 0x5e, 0x68, 0x1a, 0x5c, 0x67, 0x19, 0x5a, 0x65, 0x18, 0x5a, 0x64, 0x18, 0x59, 0x63, 0x17, 0x58, 0x62,
+    0x17, 0x57, 0x61, 0x16, 0x55, 0x60, 0x16, 0x54, 0x5f, 0x15, 0x54, 0x5e, 0x15, 0x53, 0x5d, 0x14, 0x52, 0x5c, 0x13, 0x51, 0x5b,
+    0x13, 0x50, 0x5a, 0x13, 0x4f, 0x59, 0x12, 0x4e, 0x57, 0x12, 0x4d, 0x57, 0x12, 0x4c, 0x56, 0x11, 0x4c, 0x55, 0x10, 0x4b, 0x54,
+    0x10, 0x4b, 0x54, 0x10, 0x4a, 0x53, 0x10, 0x49, 0x52, 0x10, 0x48, 0x51, 0x10, 0x47, 0x50, 0x0f, 0x46, 0x4e, 0x0e, 0x45, 0x4e,
+    0x0e, 0x44, 0x4d, 0x0e, 0x43, 0x4c, 0x0e, 0x43, 0x4b, 0x0e, 0x42, 0x4a, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47,
+    0x0d, 0x3f, 0x46, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41,
+    0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a,
+    0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x2d, 0x32, 0x09, 0x29, 0x2f, 0x36, 0x57, 0x5c,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x6f, 0x74, 0x75, 0x23, 0x6a, 0x74,
+    0x07, 0x5d, 0x69, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67,
+    0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5b, 0x67, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66, 0x06, 0x5a, 0x66,
+    0x06, 0x5a, 0x66, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65, 0x06, 0x59, 0x65,
+    0x06, 0x59, 0x65, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x64, 0x06, 0x58, 0x63, 0x06, 0x58, 0x63, 0x06, 0x57, 0x63,
+    0x06, 0x57, 0x63, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x57, 0x62, 0x06, 0x56, 0x62, 0x06, 0x56, 0x61, 0x06, 0x56, 0x61,
+    0x06, 0x55, 0x61, 0x06, 0x55, 0x60, 0x06, 0x55, 0x60, 0x06, 0x54, 0x60, 0x06, 0x54, 0x5f, 0x06, 0x54, 0x5f, 0x06, 0x53, 0x5f,
+    0x05, 0x53, 0x5e, 0x05, 0x53, 0x5e, 0x05, 0x53, 0x5d, 0x05, 0x52, 0x5d, 0x05, 0x52, 0x5c, 0x05, 0x51, 0x5c, 0x05, 0x51, 0x5b,
+    0x05, 0x50, 0x5b, 0x05, 0x4f, 0x5a, 0x05, 0x4f, 0x5a, 0x05, 0x4e, 0x59, 0x05, 0x4e, 0x58, 0x05, 0x4e, 0x58, 0x05, 0x4d, 0x57,
+    0x05, 0x4d, 0x57, 0x05, 0x4c, 0x56, 0x05, 0x4b, 0x55, 0x05, 0x4b, 0x55, 0x05, 0x4a, 0x54, 0x05, 0x4a, 0x54, 0x05, 0x49, 0x53,
+    0x05, 0x48, 0x51, 0x05, 0x48, 0x51, 0x05, 0x47, 0x50, 0x05, 0x46, 0x50, 0x05, 0x46, 0x4f, 0x05, 0x45, 0x4e, 0x05, 0x44, 0x4d,
+    0x05, 0x43, 0x4c, 0x04, 0x42, 0x4b, 0x04, 0x42, 0x4a, 0x04, 0x41, 0x49, 0x04, 0x40, 0x49, 0x04, 0x3f, 0x48, 0x04, 0x3e, 0x47,
+    0x04, 0x3d, 0x45, 0x04, 0x3c, 0x44, 0x04, 0x3b, 0x43, 0x04, 0x3a, 0x42, 0x04, 0x39, 0x41, 0x04, 0x38, 0x40, 0x04, 0x38, 0x3f,
+    0x04, 0x36, 0x3e, 0x04, 0x35, 0x3d, 0x04, 0x34, 0x3b, 0x03, 0x33, 0x3a, 0x03, 0x32, 0x38, 0x03, 0x31, 0x38, 0x03, 0x30, 0x36,
+    0x03, 0x2e, 0x35, 0x03, 0x2d, 0x33, 0x03, 0x2c, 0x32, 0x03, 0x2b, 0x31, 0x01, 0x28, 0x2e, 0x08, 0x30, 0x35, 0x9d, 0xb2, 0xb5,
+    0xff, 0xff, 0xff, 0xac, 0xca, 0xce, 0x40, 0x85, 0x8f, 0x3c, 0x82, 0x8d, 0x3c, 0x81, 0x8c, 0x3c, 0x81, 0x8c, 0x3c, 0x80, 0x8b,
+    0x3b, 0x7f, 0x8a, 0x3a, 0x7e, 0x89, 0x3a, 0x7e, 0x88, 0x39, 0x7d, 0x88, 0x38, 0x7c, 0x86, 0x37, 0x7b, 0x86, 0x36, 0x7a, 0x85,
+    0x34, 0x79, 0x84, 0x33, 0x78, 0x83, 0x32, 0x77, 0x82, 0x31, 0x76, 0x80, 0x31, 0x75, 0x80, 0x30, 0x74, 0x7e, 0x2f, 0x73, 0x7e,
+    0x2e, 0x71, 0x7c, 0x2d, 0x70, 0x7b, 0x2c, 0x6f, 0x7a, 0x2a, 0x6e, 0x79, 0x28, 0x6d, 0x77, 0x27, 0x6b, 0x75, 0x26, 0x69, 0x74,
+    0x26, 0x69, 0x73, 0x25, 0x68, 0x72, 0x24, 0x67, 0x71, 0x23, 0x65, 0x70, 0x21, 0x63, 0x6f, 0x20, 0x63, 0x6d, 0x1f, 0x61, 0x6d,
+    0x1e, 0x61, 0x6b, 0x1d, 0x60, 0x6a, 0x1c, 0x5e, 0x69, 0x1b, 0x5d, 0x67, 0x1b, 0x5c, 0x66, 0x1a, 0x5b, 0x66, 0x18, 0x59, 0x63,
+    0x18, 0x58, 0x63, 0x18, 0x57, 0x61, 0x17, 0x56, 0x60, 0x17, 0x55, 0x60, 0x16, 0x54, 0x5e, 0x16, 0x53, 0x5d, 0x14, 0x52, 0x5c,
+    0x14, 0x51, 0x5b, 0x13, 0x50, 0x5a, 0x13, 0x4f, 0x59, 0x13, 0x4f, 0x58, 0x13, 0x4e, 0x58, 0x12, 0x4c, 0x56, 0x11, 0x4b, 0x54,
+    0x11, 0x4b, 0x54, 0x11, 0x4a, 0x53, 0x10, 0x49, 0x52, 0x10, 0x48, 0x51, 0x10, 0x48, 0x51, 0x10, 0x47, 0x50, 0x0f, 0x46, 0x4f,
+    0x0f, 0x45, 0x4e, 0x0f, 0x44, 0x4d, 0x0e, 0x43, 0x4b, 0x0e, 0x43, 0x4b, 0x0e, 0x41, 0x49, 0x0d, 0x40, 0x48, 0x0d, 0x3f, 0x47,
+    0x0d, 0x3f, 0x47, 0x0d, 0x3e, 0x45, 0x0d, 0x3d, 0x45, 0x0d, 0x3c, 0x44, 0x0d, 0x3b, 0x43, 0x0c, 0x3b, 0x42, 0x0c, 0x3a, 0x41,
+    0x0c, 0x39, 0x40, 0x0c, 0x38, 0x3f, 0x0c, 0x37, 0x3e, 0x0c, 0x36, 0x3d, 0x0b, 0x35, 0x3c, 0x0b, 0x34, 0x3b, 0x0b, 0x34, 0x3a,
+    0x0b, 0x33, 0x39, 0x0b, 0x32, 0x38, 0x0a, 0x31, 0x37, 0x0a, 0x30, 0x36, 0x0a, 0x30, 0x36, 0x0a, 0x2e, 0x34, 0x0a, 0x2d, 0x32,
+    0x0a, 0x2c, 0x32, 0x12, 0x37, 0x3e, 0x3e, 0x5c, 0x61, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x5b, 0x73, 0x76, 0x39, 0x6e, 0x76, 0x2d, 0x6c, 0x75,
+    0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75,
+    0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75,
+    0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75,
+    0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75,
+    0x2d, 0x6c, 0x75, 0x2d, 0x6c, 0x75, 0x2d, 0x6b, 0x74, 0x2d, 0x6b, 0x74, 0x2d, 0x6b, 0x74, 0x2d, 0x6b, 0x74, 0x2d, 0x6b, 0x74,
+    0x2d, 0x6b, 0x74, 0x2d, 0x6b, 0x74, 0x2d, 0x6b, 0x74, 0x2d, 0x6b, 0x74, 0x2d, 0x6b, 0x74, 0x2d, 0x6b, 0x73, 0x2d, 0x6b, 0x73,
+    0x2d, 0x6b, 0x73, 0x2d, 0x6b, 0x73, 0x2c, 0x6a, 0x73, 0x2c, 0x69, 0x72, 0x2c, 0x69, 0x72, 0x2c, 0x69, 0x72, 0x2d, 0x69, 0x72,
+    0x2d, 0x69, 0x72, 0x2d, 0x69, 0x72, 0x2d, 0x69, 0x72, 0x2d, 0x69, 0x72, 0x2d, 0x69, 0x72, 0x2d, 0x69, 0x72, 0x2d, 0x69, 0x72,
+    0x2d, 0x69, 0x71, 0x2d, 0x69, 0x71, 0x2c, 0x68, 0x71, 0x2c, 0x68, 0x71, 0x2c, 0x68, 0x72, 0x2c, 0x68, 0x72, 0x2c, 0x68, 0x70,
+    0x2c, 0x68, 0x70, 0x2c, 0x67, 0x70, 0x2c, 0x67, 0x70, 0x2c, 0x67, 0x70, 0x2d, 0x67, 0x70, 0x2d, 0x67, 0x6f, 0x2c, 0x67, 0x6f,
+    0x2d, 0x67, 0x6f, 0x2d, 0x66, 0x6f, 0x2d, 0x66, 0x6f, 0x2e, 0x67, 0x6f, 0x2e, 0x67, 0x6f, 0x2e, 0x67, 0x6f, 0x2e, 0x67, 0x6f,
+    0x2d, 0x67, 0x6f, 0x2e, 0x66, 0x6f, 0x2e, 0x66, 0x6e, 0x2e, 0x66, 0x6e, 0x2e, 0x66, 0x6e, 0x2f, 0x66, 0x6d, 0x2e, 0x65, 0x6e,
+    0x2f, 0x65, 0x6e, 0x2f, 0x65, 0x6e, 0x30, 0x65, 0x6d, 0x2f, 0x65, 0x6c, 0x30, 0x65, 0x6c, 0x31, 0x65, 0x6c, 0x30, 0x64, 0x6c,
+    0x30, 0x64, 0x6b, 0x31, 0x64, 0x6c, 0x31, 0x64, 0x6b, 0x31, 0x64, 0x6b, 0x31, 0x63, 0x6b, 0x31, 0x63, 0x6a, 0x31, 0x62, 0x6a,
+    0x31, 0x62, 0x6a, 0x31, 0x62, 0x69, 0x31, 0x61, 0x69, 0x32, 0x61, 0x69, 0x31, 0x61, 0x69, 0x31, 0x61, 0x67, 0x31, 0x60, 0x66,
+    0x31, 0x60, 0x66, 0x31, 0x5f, 0x66, 0x31, 0x5f, 0x65, 0x31, 0x5f, 0x65, 0x30, 0x5e, 0x64, 0x30, 0x5d, 0x63, 0x30, 0x5d, 0x63,
+    0x30, 0x5b, 0x62, 0x2c, 0x56, 0x5d, 0x69, 0x89, 0x8d, 0xaf, 0xc2, 0xc4, 0x9d, 0xb4, 0xb7, 0x67, 0x89, 0x8f, 0x64, 0x87, 0x8c,
+    0x64, 0x87, 0x8c, 0x63, 0x87, 0x8c, 0x63, 0x87, 0x8c, 0x62, 0x85, 0x8b, 0x62, 0x85, 0x8b, 0x62, 0x84, 0x8a, 0x62, 0x84, 0x8a,
+    0x61, 0x84, 0x8a, 0x60, 0x83, 0x88, 0x60, 0x83, 0x88, 0x5f, 0x83, 0x88, 0x5e, 0x81, 0x87, 0x5e, 0x81, 0x86, 0x5d, 0x80, 0x86,
+    0x5c, 0x7f, 0x85, 0x5b, 0x7f, 0x85, 0x5a, 0x7e, 0x84, 0x59, 0x7d, 0x82, 0x59, 0x7c, 0x82, 0x58, 0x7c, 0x82, 0x57, 0x7b, 0x81,
+    0x57, 0x7b, 0x80, 0x55, 0x7a, 0x7f, 0x54, 0x79, 0x7e, 0x54, 0x77, 0x7d, 0x54, 0x77, 0x7d, 0x52, 0x77, 0x7c, 0x51, 0x76, 0x7b,
+    0x50, 0x75, 0x7b, 0x4f, 0x74, 0x79, 0x4f, 0x73, 0x79, 0x4e, 0x72, 0x78, 0x4d, 0x72, 0x78, 0x4c, 0x71, 0x77, 0x4b, 0x70, 0x76,
+    0x4b, 0x70, 0x76, 0x4a, 0x70, 0x75, 0x49, 0x6f, 0x75, 0x49, 0x6e, 0x74, 0x48, 0x6d, 0x73, 0x47, 0x6c, 0x71, 0x47, 0x6c, 0x71,
+    0x46, 0x6b, 0x71, 0x46, 0x6b, 0x71, 0x45, 0x6a, 0x70, 0x45, 0x6a, 0x70, 0x45, 0x6a, 0x70, 0x45, 0x68, 0x6e, 0x45, 0x68, 0x6e,
+    0x45, 0x68, 0x6e, 0x44, 0x68, 0x6d, 0x44, 0x68, 0x6d, 0x43, 0x67, 0x6c, 0x43, 0x67, 0x6c, 0x42, 0x65, 0x6c, 0x42, 0x65, 0x6c,
+    0x42, 0x65, 0x6b, 0x42, 0x65, 0x6b, 0x41, 0x65, 0x6b, 0x41, 0x64, 0x6a, 0x41, 0x64, 0x6a, 0x40, 0x63, 0x69, 0x40, 0x63, 0x69,
+    0x40, 0x63, 0x69, 0x3f, 0x63, 0x68, 0x3f, 0x63, 0x68, 0x3f, 0x62, 0x68, 0x3f, 0x61, 0x67, 0x3f, 0x61, 0x67, 0x3f, 0x61, 0x67,
+    0x3f, 0x60, 0x67, 0x3e, 0x60, 0x65, 0x3e, 0x60, 0x65, 0x3e, 0x60, 0x65, 0x3e, 0x5f, 0x65, 0x3e, 0x5f, 0x65, 0x3d, 0x5f, 0x64,
+    0x3d, 0x5f, 0x64, 0x3d, 0x5e, 0x64, 0x3d, 0x5e, 0x63, 0x3d, 0x5e, 0x63, 0x3d, 0x5d, 0x63, 0x3d, 0x5d, 0x63, 0x3c, 0x5c, 0x62,
+    0x3b, 0x5c, 0x61, 0x3c, 0x5b, 0x60, 0x3c, 0x5b, 0x60, 0x3c, 0x5b, 0x60, 0x4a, 0x63, 0x67, 0x67, 0x70, 0x71, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f,
+    0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x82, 0x82, 0x82, 0x83, 0x83, 0x83,
+    0x83, 0x83, 0x83, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x86, 0x86, 0x86,
+    0x86, 0x86, 0x86, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+    0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+    0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+    0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x85, 0x85, 0x85,
+    0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+    0x82, 0x82, 0x82, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+    0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7b, 0x7b, 0x7b, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x82, 0x82, 0x82, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+    0x83, 0x83, 0x83, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x86, 0x86, 0x86,
+    0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+    0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+    0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+    0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x83, 0x83, 0x83,
+    0x83, 0x83, 0x83, 0x82, 0x82, 0x82, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+    0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d,
+    0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7b, 0x7b, 0x7b, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d,
+    0x7d, 0x7d, 0x7d, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80,
+    0x80, 0x80, 0x80, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x82, 0x82, 0x82, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+    0x83, 0x83, 0x83, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+    0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+    0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+    0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x83, 0x83, 0x83,
+    0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x80, 0x80, 0x80,
+    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e,
+    0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7b, 0x7b, 0x7b, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7b, 0x7b, 0x7b, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d,
+    0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+    0x80, 0x80, 0x80, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x83, 0x83, 0x83,
+    0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+    0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+    0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+    0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x82, 0x82, 0x82, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+    0x81, 0x81, 0x81, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7e, 0x7e, 0x7e,
+    0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7b, 0x7b, 0x7b, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7b, 0x7b, 0x7b,
+    0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7e, 0x7e, 0x7e,
+    0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+    0x80, 0x80, 0x80, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+    0x82, 0x82, 0x82, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+    0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+    0x83, 0x83, 0x83, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+    0x81, 0x81, 0x81, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+    0x7f, 0x7f, 0x7f, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e,
+    0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+    0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+    0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+    0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d,
+    0x7d, 0x7d, 0x7d, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e,
+    0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+    0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7d, 0x7d, 0x7d,
+    0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7b, 0x7b, 0x7b,
+    0x7b, 0x7b, 0x7b, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7e, 0x7e, 0x7e,
+    0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+    0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+    0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+    0x7f, 0x7f, 0x7f, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e,
+    0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d,
+    0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e,
+    0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e,
+    0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7d, 0x7d, 0x7d,
+    0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d,
+    0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d,
+    0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d,
+    0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b,
+    0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c,
+    0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7b, 0x7b, 0x7b,
+    0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a,
+    0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x7a, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
+    0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
+    0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76,
+    0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x76, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75,
+    0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75};
+static unsigned int lunarg_ppm_len = 196623;
diff --git a/tools/Vulkan-Tools/cube/macOS/cube/AppDelegate.h b/tools/Vulkan-Tools/cube/macOS/cube/AppDelegate.h
new file mode 100644
index 00000000..0b1dfe49
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/macOS/cube/AppDelegate.h
@@ -0,0 +1,23 @@
+/*
+ * AppDelegate.h
+ *
+ * Copyright (c) 2014-2018 The Brenwill Workshop Ltd. (http://www.brenwill.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <Cocoa/Cocoa.h>
+
+@interface AppDelegate : NSObject<NSApplicationDelegate>
+
+@end
diff --git a/tools/Vulkan-Tools/cube/macOS/cube/AppDelegate.m b/tools/Vulkan-Tools/cube/macOS/cube/AppDelegate.m
new file mode 100644
index 00000000..c1ee96b4
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/macOS/cube/AppDelegate.m
@@ -0,0 +1,48 @@
+/*
+ * AppDelegate.m
+ *
+ * Copyright (c) 2014-2018 The Brenwill Workshop Ltd. (http://www.brenwill.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "AppDelegate.h"
+#import "DemoViewController.h"
+
+@interface AppDelegate ()
+
+@end
+
+@implementation AppDelegate
+
+- (void)applicationDidFinishLaunching:(NSNotification *)aNotification {
+    // Insert code here to initialize your application
+}
+
+- (void)applicationWillTerminate:(NSNotification *)aNotification {
+    NSApplication *app = aNotification.object;
+    NSArray<NSWindow *> *windows = app.windows;
+    for (NSUInteger i = 0; i < windows.count; ++i) {
+        NSViewController *viewController = windows[i].contentViewController;
+        if ([viewController isKindOfClass:[DemoViewController class]]) {
+            [(DemoViewController *)viewController quit];
+            break;
+        }
+    }
+}
+
+- (BOOL)applicationShouldTerminateAfterLastWindowClosed:(NSApplication *)sender {
+    return YES;
+}
+
+@end
diff --git a/tools/Vulkan-Tools/cube/macOS/cube/CMakeLists.txt b/tools/Vulkan-Tools/cube/macOS/cube/CMakeLists.txt
new file mode 100644
index 00000000..d0721a89
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/macOS/cube/CMakeLists.txt
@@ -0,0 +1,93 @@
+# ~~~
+# Copyright (c) 2018-2024 Valve Corporation
+# Copyright (c) 2018-2024 LunarG, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ~~~
+
+# VkCube Application Bundle
+
+set(cube_RESOURCES ${CMAKE_CURRENT_LIST_DIR}/Resources/VulkanIcon.icns)
+if(NOT APPLE_USE_SYSTEM_ICD)
+    list(APPEND cube_RESOURCES ${PROJECT_BINARY_DIR}/staging-json/MoltenVK_icd.json)
+endif()
+
+# Have Xcode handle the Storyboard
+if(XCODE)
+    set(cube_RESOURCES ${cube_RESOURCES} ${CMAKE_CURRENT_LIST_DIR}/Resources/Main.storyboard)
+endif()
+
+add_executable(vkcube MACOSX_BUNDLE)
+
+target_sources(vkcube PRIVATE
+    main.m
+    AppDelegate.m
+    AppDelegate.h
+    DemoViewController.m
+    DemoViewController.h
+    ${cube_RESOURCES}
+    ../../cube.vert.inc
+    ../../cube.frag.inc
+)
+
+# Handle the Storyboard ourselves
+if(NOT XCODE)
+    # Compile the storyboard file with the ibtool.
+    add_custom_command(TARGET vkcube POST_BUILD
+                       COMMAND ${IBTOOL}
+                               --errors
+                               --warnings
+                               --notices
+                               --output-format human-readable-text
+                               --compile ${CMAKE_CURRENT_BINARY_DIR}/vkcube.app/Contents/Resources/Main.storyboardc
+                                         ${CMAKE_CURRENT_LIST_DIR}/Resources/Main.storyboard
+                       COMMENT "Compiling storyboard")
+endif()
+
+if(NOT APPLE_USE_SYSTEM_ICD)
+    add_dependencies(vkcube MoltenVK_icd-staging-json)
+endif()
+
+# Include demo source code dir because the MacOS cube's Objective-C source includes the "original" cube application C source code.
+target_include_directories(vkcube PRIVATE ${CMAKE_CURRENT_LIST_DIR})
+
+# We do this so vkcube is linked to an individual library and NOT a framework.
+target_link_libraries(vkcube Vulkan::Loader "-framework Cocoa -framework QuartzCore")
+
+# Disable warnings about sprintf
+target_compile_options(vkcube PRIVATE -Wno-deprecated-declarations)
+
+set_target_properties(vkcube PROPERTIES MACOSX_BUNDLE_INFO_PLIST ${CMAKE_CURRENT_LIST_DIR}/Info.plist)
+
+# The RESOURCE target property cannot be used in conjunction with the MACOSX_PACKAGE_LOCATION property.  We need fine-grained
+# control over the Resource directory, so we have to specify the destination of all the resource files on a per-destination-
+# directory basis. If all the files went into the top-level Resource directory, then we could simply set the RESOURCE property to a
+# list of all the resource files.
+set_source_files_properties(${cube_RESOURCES} PROPERTIES MACOSX_PACKAGE_LOCATION "Resources")
+if(NOT APPLE_USE_SYSTEM_ICD)
+    set_source_files_properties("${PROJECT_BINARY_DIR}/staging-json/MoltenVK_icd.json"
+                                PROPERTIES
+                                MACOSX_PACKAGE_LOCATION
+                                "Resources/vulkan/icd.d")
+
+    # Copy the MoltenVK lib into the bundle.
+    if(XCODE)
+        add_custom_command(TARGET vkcube POST_BUILD
+                           COMMAND ${CMAKE_COMMAND} -E copy "${MOLTENVK_DIR}/Package/Release/MoltenVK/dynamic/dylib/macOS/libMoltenVK.dylib"
+                                   ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>/vkcube.app/Contents/Frameworks/libMoltenVK.dylib)
+    else()
+        add_custom_command(TARGET vkcube POST_BUILD
+                           COMMAND ${CMAKE_COMMAND} -E copy "${MOLTENVK_DIR}/Package/Release/MoltenVK/dynamic/dylib/macOS/libMoltenVK.dylib"
+                                   ${CMAKE_CURRENT_BINARY_DIR}/vkcube.app/Contents/Frameworks/libMoltenVK.dylib)
+    endif()
+endif()
diff --git a/tools/Vulkan-Tools/cube/macOS/cube/DemoViewController.h b/tools/Vulkan-Tools/cube/macOS/cube/DemoViewController.h
new file mode 100644
index 00000000..6d7ca215
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/macOS/cube/DemoViewController.h
@@ -0,0 +1,36 @@
+/*
+ * DemoViewController.h
+ *
+ * Copyright (c) 2014-2018 The Brenwill Workshop Ltd. (http://www.brenwill.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <AppKit/AppKit.h>
+
+#pragma mark -
+#pragma mark DemoViewController
+
+/** The main view controller for the demo storyboard. */
+@interface DemoViewController : NSViewController
+
+- (void)quit;
+
+@end
+
+#pragma mark -
+#pragma mark DemoView
+
+/** The Metal-compatibile view for the demo Storyboard. */
+@interface DemoView : NSView
+@end
diff --git a/tools/Vulkan-Tools/cube/macOS/cube/DemoViewController.m b/tools/Vulkan-Tools/cube/macOS/cube/DemoViewController.m
new file mode 100644
index 00000000..d2158521
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/macOS/cube/DemoViewController.m
@@ -0,0 +1,119 @@
+/*
+ * DemoViewController.m
+ *
+ * Copyright (c) 2014-2018 The Brenwill Workshop Ltd. (http://www.brenwill.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "DemoViewController.h"
+#import <QuartzCore/CAMetalLayer.h>
+
+#include "cube.c"
+
+#pragma mark -
+#pragma mark DemoViewController
+
+@implementation DemoViewController {
+    CVDisplayLinkRef _displayLink;
+    struct demo demo;
+    NSTimer* _timer;
+}
+
+- (void)dealloc {
+    [self quit];
+    [super dealloc];
+}
+
+- (void)quit {
+    CVDisplayLinkRelease(_displayLink);
+    demo_cleanup(&demo);
+}
+
+/** Since this is a single-view app, initialize Vulkan during view loading. */
+- (void)viewDidLoad {
+    [super viewDidLoad];
+
+    self.view.wantsLayer = YES;  // Back the view with a layer created by the makeBackingLayer method.
+
+    // Convert incoming args to "C" argc/argv strings
+    NSArray *args = [[NSProcessInfo processInfo] arguments];
+    const char** argv = (const char**) alloca(sizeof(char*) * args.count);
+    for(unsigned int i = 0; i < args.count; i++) {
+        NSString *s = args[i];
+        argv[i] = s.UTF8String;
+    }
+
+    demo_main(&demo, self.view.layer, args.count, argv);
+
+    // Monitor the rendering loop for a quit condition
+    _timer = [NSTimer scheduledTimerWithTimeInterval: 0.2
+                                              target: self
+                                            selector: @selector(onTick:)
+                                            userInfo: self
+                                             repeats: YES];
+
+    // Start the rendering loop
+    CVDisplayLinkCreateWithActiveCGDisplays(&_displayLink);
+    CVDisplayLinkSetOutputCallback(_displayLink, &DisplayLinkCallback, &demo);
+    CVDisplayLinkStart(_displayLink);
+
+}
+
+// Close the window if the demo is in a Quit state
+-(void)onTick:(NSTimer*)timer {
+    if (demo.quit) {
+        [[[self view] window] close];
+    }
+}
+
+#pragma mark Display loop callback function
+
+/** Rendering loop callback function for use with a CVDisplayLink. */
+static CVReturn DisplayLinkCallback(CVDisplayLinkRef displayLink, const CVTimeStamp* now,
+                                    const CVTimeStamp* outputTime,
+                                    CVOptionFlags flagsIn, CVOptionFlags* flagsOut, void* target) {
+    struct demo* demo = (struct demo*)target;
+    demo_run(demo);
+    if (demo->quit) {
+        CVDisplayLinkStop(displayLink);
+    }
+    return kCVReturnSuccess;
+}
+
+@end
+
+#pragma mark -
+#pragma mark DemoView
+
+@implementation DemoView
+
+/** Indicates that the view wants to draw using the backing layer instead of using drawRect:.  */
+- (BOOL)wantsUpdateLayer {
+    return YES;
+}
+
+/** Returns a Metal-compatible layer. */
++ (Class)layerClass {
+    return [CAMetalLayer class];
+}
+
+/** If the wantsLayer property is set to YES, this method will be invoked to return a layer instance. */
+- (CALayer*)makeBackingLayer {
+    CALayer* layer = [self.class.layerClass layer];
+    CGSize viewScale = [self convertSizeToBacking:CGSizeMake(1.0, 1.0)];
+    layer.contentsScale = MIN(viewScale.width, viewScale.height);
+    return layer;
+}
+
+@end
diff --git a/tools/Vulkan-Tools/cube/macOS/cube/Info.plist b/tools/Vulkan-Tools/cube/macOS/cube/Info.plist
new file mode 100644
index 00000000..55145d32
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/macOS/cube/Info.plist
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>English</string>
+	<key>CFBundleExecutable</key>
+	<string>${MACOSX_BUNDLE_EXECUTABLE_NAME}</string>
+	<key>CFBundleGetInfoString</key>
+	<string>VkCube</string>
+	<key>CFBundleIconFile</key>
+	<string>VulkanIcon.icns</string>
+	<key>CFBundleIdentifier</key>
+	<string>com.lunarg.vkcube</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleLongVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleName</key>
+	<string>VkCube</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>1.0</string>
+	<key>CSResourcesFileMapped</key>
+	<true/>
+	<key>NSHumanReadableCopyright</key>
+	<string>Copyright (c) 2018 The Khronos Group Inc. LunarG Inc. All rights reserved.</string>
+	<key>NSMainStoryboardFile</key>
+	<string>Main</string>
+	<key>NSPrincipalClass</key>
+	<string>NSApplication</string>
+</dict>
+</plist>
diff --git a/tools/Vulkan-Tools/cube/macOS/cube/Resources/Main.storyboard b/tools/Vulkan-Tools/cube/macOS/cube/Resources/Main.storyboard
new file mode 100644
index 00000000..edc63148
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/macOS/cube/Resources/Main.storyboard
@@ -0,0 +1,131 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<document type="com.apple.InterfaceBuilder3.Cocoa.Storyboard.XIB" version="3.0" toolsVersion="10117" systemVersion="15G26a" targetRuntime="MacOSX.Cocoa" propertyAccessControl="none" useAutolayout="YES" initialViewController="B8D-0N-5wS">
+    <dependencies>
+        <deployment identifier="macosx"/>
+        <plugIn identifier="com.apple.InterfaceBuilder.CocoaPlugin" version="10117"/>
+    </dependencies>
+    <scenes>
+        <!--Application-->
+        <scene sceneID="JPo-4y-FX3">
+            <objects>
+                <application id="hnw-xV-0zn" sceneMemberID="viewController">
+                    <menu key="mainMenu" title="Main Menu" systemMenu="main" id="AYu-sK-qS6">
+                        <items>
+                            <menuItem title="VkCube" id="1Xt-HY-uBw">
+                                <modifierMask key="keyEquivalentModifierMask"/>
+                                <menu key="submenu" title="VkCube" systemMenu="apple" id="uQy-DD-JDr">
+                                    <items>
+                                        <menuItem title="About Demo" id="5kV-Vb-QxS">
+                                            <modifierMask key="keyEquivalentModifierMask"/>
+                                            <connections>
+                                                <action selector="orderFrontStandardAboutPanel:" target="Ady-hI-5gd" id="Exp-CZ-Vem"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem isSeparatorItem="YES" id="VOq-y0-SEH"/>
+                                        <menuItem title="Hide Demo" keyEquivalent="h" id="Olw-nP-bQN">
+                                            <connections>
+                                                <action selector="hide:" target="Ady-hI-5gd" id="PnN-Uc-m68"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem title="Hide Others" keyEquivalent="h" id="Vdr-fp-XzO">
+                                            <modifierMask key="keyEquivalentModifierMask" option="YES" command="YES"/>
+                                            <connections>
+                                                <action selector="hideOtherApplications:" target="Ady-hI-5gd" id="VT4-aY-XCT"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem title="Show All" id="Kd2-mp-pUS">
+                                            <modifierMask key="keyEquivalentModifierMask"/>
+                                            <connections>
+                                                <action selector="unhideAllApplications:" target="Ady-hI-5gd" id="Dhg-Le-xox"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem isSeparatorItem="YES" id="kCx-OE-vgT"/>
+                                        <menuItem title="Quit Demo" keyEquivalent="q" id="4sb-4s-VLi">
+                                            <connections>
+                                                <action selector="terminate:" target="Ady-hI-5gd" id="Te7-pn-YzF"/>
+                                            </connections>
+                                        </menuItem>
+                                    </items>
+                                </menu>
+                            </menuItem>
+                            <menuItem title="Window" id="aUF-d1-5bR">
+                                <modifierMask key="keyEquivalentModifierMask"/>
+                                <menu key="submenu" title="Window" systemMenu="window" id="Td7-aD-5lo">
+                                    <items>
+                                        <menuItem title="Minimize" keyEquivalent="m" id="OY7-WF-poV">
+                                            <connections>
+                                                <action selector="performMiniaturize:" target="Ady-hI-5gd" id="VwT-WD-YPe"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem title="Zoom" id="R4o-n2-Eq4">
+                                            <modifierMask key="keyEquivalentModifierMask"/>
+                                            <connections>
+                                                <action selector="performZoom:" target="Ady-hI-5gd" id="DIl-cC-cCs"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem isSeparatorItem="YES" id="eu3-7i-yIM"/>
+                                        <menuItem title="Bring All to Front" id="LE2-aR-0XJ">
+                                            <modifierMask key="keyEquivalentModifierMask"/>
+                                            <connections>
+                                                <action selector="arrangeInFront:" target="Ady-hI-5gd" id="DRN-fu-gQh"/>
+                                            </connections>
+                                        </menuItem>
+                                    </items>
+                                </menu>
+                            </menuItem>
+                            <menuItem title="Help" id="wpr-3q-Mcd">
+                                <modifierMask key="keyEquivalentModifierMask"/>
+                                <menu key="submenu" title="Help" systemMenu="help" id="F2S-fz-NVQ">
+                                    <items>
+                                        <menuItem title="VkCube Help" keyEquivalent="?" id="FKE-Sm-Kum">
+                                            <connections>
+                                                <action selector="showHelp:" target="Ady-hI-5gd" id="y7X-2Q-9no"/>
+                                            </connections>
+                                        </menuItem>
+                                    </items>
+                                </menu>
+                            </menuItem>
+                        </items>
+                    </menu>
+                    <connections>
+                        <outlet property="delegate" destination="Voe-Tx-rLC" id="PrD-fu-P6m"/>
+                    </connections>
+                </application>
+                <customObject id="Voe-Tx-rLC" customClass="AppDelegate"/>
+                <customObject id="Ady-hI-5gd" userLabel="First Responder" customClass="NSResponder" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="83.5" y="-47"/>
+        </scene>
+        <!--Window Controller-->
+        <scene sceneID="R2V-B0-nI4">
+            <objects>
+                <windowController id="B8D-0N-5wS" sceneMemberID="viewController">
+                    <window key="window" title="VkCube" allowsToolTipsWhenApplicationIsInactive="NO" autorecalculatesKeyViewLoop="NO" oneShot="NO" releasedWhenClosed="NO" showsToolbarButton="NO" visibleAtLaunch="NO" animationBehavior="default" id="IQv-IB-iLA">
+                        <windowStyleMask key="styleMask" titled="YES" closable="YES" miniaturizable="YES" resizable="YES"/>
+                        <rect key="contentRect" x="1051" y="656" width="300" height="200"/>
+                        <rect key="screenRect" x="0.0" y="0.0" width="2560" height="1417"/>
+                        <value key="minSize" type="size" width="300" height="200"/>
+                    </window>
+                    <connections>
+                        <segue destination="XfG-lQ-9wD" kind="relationship" relationship="window.shadowedContentViewController" id="cq2-FE-JQM"/>
+                    </connections>
+                </windowController>
+                <customObject id="Oky-zY-oP4" userLabel="First Responder" customClass="NSResponder" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="83" y="146"/>
+        </scene>
+        <!--Demo View Controller-->
+        <scene sceneID="hIz-AP-VOD">
+            <objects>
+                <viewController id="XfG-lQ-9wD" customClass="DemoViewController" sceneMemberID="viewController">
+                    <view key="view" id="m2S-Jp-Qdl" customClass="DemoView">
+                        <rect key="frame" x="0.0" y="0.0" width="400" height="300"/>
+                        <autoresizingMask key="autoresizingMask"/>
+                    </view>
+                </viewController>
+                <customObject id="rPt-NT-nkU" userLabel="First Responder" customClass="NSResponder" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="83" y="564"/>
+        </scene>
+    </scenes>
+</document>
diff --git a/tools/Vulkan-Tools/cube/macOS/cube/Resources/VulkanIcon.icns b/tools/Vulkan-Tools/cube/macOS/cube/Resources/VulkanIcon.icns
new file mode 100644
index 00000000..fb82fb7d
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/macOS/cube/Resources/VulkanIcon.icns
diff --git a/tools/Vulkan-Tools/cube/macOS/cube/main.m b/tools/Vulkan-Tools/cube/macOS/cube/main.m
new file mode 100644
index 00000000..cf9e0d89
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/macOS/cube/main.m
@@ -0,0 +1,21 @@
+/*
+ * main.m
+ *
+ * Copyright (c) 2014-2018 The Brenwill Workshop Ltd. (http://www.brenwill.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <Cocoa/Cocoa.h>
+
+int main(int argc, const char* argv[]) { return NSApplicationMain(argc, argv); }
diff --git a/tools/Vulkan-Tools/cube/macOS/cubepp/AppDelegate.h b/tools/Vulkan-Tools/cube/macOS/cubepp/AppDelegate.h
new file mode 100644
index 00000000..0b1dfe49
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/macOS/cubepp/AppDelegate.h
@@ -0,0 +1,23 @@
+/*
+ * AppDelegate.h
+ *
+ * Copyright (c) 2014-2018 The Brenwill Workshop Ltd. (http://www.brenwill.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <Cocoa/Cocoa.h>
+
+@interface AppDelegate : NSObject<NSApplicationDelegate>
+
+@end
diff --git a/tools/Vulkan-Tools/cube/macOS/cubepp/AppDelegate.mm b/tools/Vulkan-Tools/cube/macOS/cubepp/AppDelegate.mm
new file mode 100644
index 00000000..c1ee96b4
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/macOS/cubepp/AppDelegate.mm
@@ -0,0 +1,48 @@
+/*
+ * AppDelegate.m
+ *
+ * Copyright (c) 2014-2018 The Brenwill Workshop Ltd. (http://www.brenwill.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "AppDelegate.h"
+#import "DemoViewController.h"
+
+@interface AppDelegate ()
+
+@end
+
+@implementation AppDelegate
+
+- (void)applicationDidFinishLaunching:(NSNotification *)aNotification {
+    // Insert code here to initialize your application
+}
+
+- (void)applicationWillTerminate:(NSNotification *)aNotification {
+    NSApplication *app = aNotification.object;
+    NSArray<NSWindow *> *windows = app.windows;
+    for (NSUInteger i = 0; i < windows.count; ++i) {
+        NSViewController *viewController = windows[i].contentViewController;
+        if ([viewController isKindOfClass:[DemoViewController class]]) {
+            [(DemoViewController *)viewController quit];
+            break;
+        }
+    }
+}
+
+- (BOOL)applicationShouldTerminateAfterLastWindowClosed:(NSApplication *)sender {
+    return YES;
+}
+
+@end
diff --git a/tools/Vulkan-Tools/cube/macOS/cubepp/CMakeLists.txt b/tools/Vulkan-Tools/cube/macOS/cubepp/CMakeLists.txt
new file mode 100644
index 00000000..6390db0b
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/macOS/cubepp/CMakeLists.txt
@@ -0,0 +1,91 @@
+# ~~~
+# Copyright (c) 2018-2024 Valve Corporation
+# Copyright (c) 2018-2024 LunarG, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ~~~
+
+# VkCube Application Bundle
+
+set(cubepp_RESOURCES ${CMAKE_CURRENT_LIST_DIR}/Resources/VulkanIcon.icns)
+if(NOT APPLE_USE_SYSTEM_ICD)
+    list(APPEND cubepp_RESOURCES ${PROJECT_BINARY_DIR}/staging-json/MoltenVK_icd.json)
+endif()
+
+# Have Xcode handle the Storyboard
+if(XCODE)
+    set(cubepp_RESOURCES ${cubepp_RESOURCES} ${CMAKE_CURRENT_LIST_DIR}/Resources/Main.storyboard)
+endif()
+
+add_executable(vkcubepp MACOSX_BUNDLE)
+
+target_sources(vkcubepp PRIVATE
+    main.mm
+    AppDelegate.mm
+    AppDelegate.h
+    DemoViewController.h
+    DemoViewController.mm
+    ${cubepp_RESOURCES}
+    ../../cube.vert.inc
+    ../../cube.frag.inc
+)
+
+# Handle the Storyboard ourselves
+if(NOT XCODE)
+    # Compile the storyboard file with the ibtool.
+    add_custom_command(TARGET vkcubepp POST_BUILD
+                       COMMAND ${IBTOOL}
+                               --errors
+                               --warnings
+                               --notices
+                               --output-format human-readable-text
+                               --compile ${CMAKE_CURRENT_BINARY_DIR}/vkcubepp.app/Contents/Resources/Main.storyboardc
+                                         ${CMAKE_CURRENT_LIST_DIR}/Resources/Main.storyboard
+                       COMMENT "Compiling storyboard")
+endif()
+
+if(NOT APPLE_USE_SYSTEM_ICD)
+    add_dependencies(vkcubepp MoltenVK_icd-staging-json)
+endif()
+
+# Include demo source code dir because the MacOS vkcubepp's Objective-C source includes the "original" vkcubepp application C++ source
+# code.
+target_include_directories(vkcubepp PRIVATE ${CMAKE_CURRENT_LIST_DIR})
+
+# We do this so vkcubepp is linked to an individual library and NOT a framework.
+target_link_libraries(vkcubepp Vulkan::Loader "-framework Cocoa -framework QuartzCore")
+
+set_target_properties(vkcubepp PROPERTIES MACOSX_BUNDLE_INFO_PLIST ${CMAKE_CURRENT_LIST_DIR}/Info.plist)
+
+# The RESOURCE target property cannot be used in conjunction with the MACOSX_PACKAGE_LOCATION property.  We need fine-grained
+# control over the Resource directory, so we have to specify the destination of all the resource files on a per-destination-
+# directory basis. If all the files went into the top-level Resource directory, then we could simply set the RESOURCE property to a
+# list of all the resource files.
+set_source_files_properties(${cubepp_RESOURCES} PROPERTIES MACOSX_PACKAGE_LOCATION "Resources")
+if(NOT APPLE_USE_SYSTEM_ICD)
+    set_source_files_properties("${PROJECT_BINARY_DIR}/staging-json/MoltenVK_icd.json"
+                                PROPERTIES
+                                MACOSX_PACKAGE_LOCATION
+                                "Resources/vulkan/icd.d")
+
+    # Copy the MoltenVK lib into the bundle.
+    if(XCODE)
+        add_custom_command(TARGET vkcubepp POST_BUILD
+                           COMMAND ${CMAKE_COMMAND} -E copy "${MOLTENVK_DIR}/Package/Release/MoltenVK/dynamic/dylib/macOS/libMoltenVK.dylib"
+                                   ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>/vkcubepp.app/Contents/Frameworks/libMoltenVK.dylib)
+    else()
+        add_custom_command(TARGET vkcubepp POST_BUILD
+                           COMMAND ${CMAKE_COMMAND} -E copy "${MOLTENVK_DIR}/Package/Release/MoltenVK/dynamic/dylib/macOS/libMoltenVK.dylib"
+                                   ${CMAKE_CURRENT_BINARY_DIR}/vkcubepp.app/Contents/Frameworks/libMoltenVK.dylib)
+    endif()
+endif()
diff --git a/tools/Vulkan-Tools/cube/macOS/cubepp/DemoViewController.h b/tools/Vulkan-Tools/cube/macOS/cubepp/DemoViewController.h
new file mode 100644
index 00000000..6d7ca215
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/macOS/cubepp/DemoViewController.h
@@ -0,0 +1,36 @@
+/*
+ * DemoViewController.h
+ *
+ * Copyright (c) 2014-2018 The Brenwill Workshop Ltd. (http://www.brenwill.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <AppKit/AppKit.h>
+
+#pragma mark -
+#pragma mark DemoViewController
+
+/** The main view controller for the demo storyboard. */
+@interface DemoViewController : NSViewController
+
+- (void)quit;
+
+@end
+
+#pragma mark -
+#pragma mark DemoView
+
+/** The Metal-compatibile view for the demo Storyboard. */
+@interface DemoView : NSView
+@end
diff --git a/tools/Vulkan-Tools/cube/macOS/cubepp/DemoViewController.mm b/tools/Vulkan-Tools/cube/macOS/cubepp/DemoViewController.mm
new file mode 100644
index 00000000..fbb17797
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/macOS/cubepp/DemoViewController.mm
@@ -0,0 +1,118 @@
+/*
+ * DemoViewController.m
+ *
+ * Copyright (c) 2014-2018 The Brenwill Workshop Ltd. (http://www.brenwill.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "DemoViewController.h"
+#import <QuartzCore/CAMetalLayer.h>
+
+#include "cube.cpp"
+
+#pragma mark -
+#pragma mark DemoViewController
+
+@implementation DemoViewController {
+    CVDisplayLinkRef _displayLink;
+    struct Demo demo;
+    NSTimer* _timer;
+}
+
+- (void)dealloc {
+    [self quit];
+    [super dealloc];
+}
+
+- (void)quit {
+    CVDisplayLinkRelease(_displayLink);
+    demo.cleanup();
+}
+
+/** Since this is a single-view app, initialize Vulkan during view loading. */
+- (void)viewDidLoad {
+    [super viewDidLoad];
+
+    self.view.wantsLayer = YES;  // Back the view with a layer created by the makeBackingLayer method.
+
+    // Convert incoming args to "C" argc/argv strings
+    NSArray *args = [[NSProcessInfo processInfo] arguments];
+    const char** argv = (const char**) alloca(sizeof(char*) * args.count);
+    for(unsigned int i = 0; i < args.count; i++) {
+        NSString *s = args[i];
+        argv[i] = s.UTF8String;
+    }
+
+    demo_main(demo, self.view.layer, args.count, argv);
+
+    // Monitor the rendering loop for a quit condition
+    _timer = [NSTimer scheduledTimerWithTimeInterval: 0.2
+                                              target: self
+                                            selector: @selector(onTick:)
+                                            userInfo: self
+                                             repeats: YES];
+
+    // Start the rendering loop
+    CVDisplayLinkCreateWithActiveCGDisplays(&_displayLink);
+    CVDisplayLinkSetOutputCallback(_displayLink, &DisplayLinkCallback, &demo);
+    CVDisplayLinkStart(_displayLink);
+}
+
+// Close the window if the demo is in a Quit state
+-(void)onTick:(NSTimer*)timer {
+    if (demo.quit) {
+        [[[self view] window] close];
+    }
+}
+
+#pragma mark Display loop callback function
+
+/** Rendering loop callback function for use with a CVDisplayLink. */
+static CVReturn DisplayLinkCallback(CVDisplayLinkRef displayLink, const CVTimeStamp* now,
+                                    const CVTimeStamp* outputTime,
+                                    CVOptionFlags flagsIn, CVOptionFlags* flagsOut, void* target) {
+    struct Demo* demo = (struct Demo*)target;
+    demo->run<WsiPlatform::metal>();
+    if (demo->quit) {
+        CVDisplayLinkStop(displayLink);
+    }
+    return kCVReturnSuccess;
+}
+
+@end
+
+#pragma mark -
+#pragma mark DemoView
+
+@implementation DemoView
+
+/** Indicates that the view wants to draw using the backing layer instead of using drawRect:.  */
+- (BOOL)wantsUpdateLayer {
+    return YES;
+}
+
+/** Returns a Metal-compatible layer. */
++ (Class)layerClass {
+    return [CAMetalLayer class];
+}
+
+/** If the wantsLayer property is set to YES, this method will be invoked to return a layer instance. */
+- (CALayer*)makeBackingLayer {
+    CALayer* layer = [self.class.layerClass layer];
+    CGSize viewScale = [self convertSizeToBacking:CGSizeMake(1.0, 1.0)];
+    layer.contentsScale = MIN(viewScale.width, viewScale.height);
+    return layer;
+}
+
+@end
diff --git a/tools/Vulkan-Tools/cube/macOS/cubepp/Info.plist b/tools/Vulkan-Tools/cube/macOS/cubepp/Info.plist
new file mode 100644
index 00000000..d0b74e01
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/macOS/cubepp/Info.plist
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>English</string>
+	<key>CFBundleExecutable</key>
+	<string>${MACOSX_BUNDLE_EXECUTABLE_NAME}</string>
+	<key>CFBundleGetInfoString</key>
+	<string>VkCubepp</string>
+	<key>CFBundleIconFile</key>
+	<string>VulkanIcon.icns</string>
+	<key>CFBundleIdentifier</key>
+	<string>com.lunarg.cubepp</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleLongVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleName</key>
+	<string>VkCubepp</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>1.0</string>
+	<key>CSResourcesFileMapped</key>
+	<true/>
+	<key>NSHumanReadableCopyright</key>
+	<string>Copyright (c) 2018 The Khronos Group Inc. LunarG Inc. All rights reserved.</string>
+	<key>NSMainStoryboardFile</key>
+	<string>Main</string>
+	<key>NSPrincipalClass</key>
+	<string>NSApplication</string>
+</dict>
+</plist>
diff --git a/tools/Vulkan-Tools/cube/macOS/cubepp/Resources/Main.storyboard b/tools/Vulkan-Tools/cube/macOS/cubepp/Resources/Main.storyboard
new file mode 100644
index 00000000..abae39be
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/macOS/cubepp/Resources/Main.storyboard
@@ -0,0 +1,131 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<document type="com.apple.InterfaceBuilder3.Cocoa.Storyboard.XIB" version="3.0" toolsVersion="10117" systemVersion="15G26a" targetRuntime="MacOSX.Cocoa" propertyAccessControl="none" useAutolayout="YES" initialViewController="B8D-0N-5wS">
+    <dependencies>
+        <deployment identifier="macosx"/>
+        <plugIn identifier="com.apple.InterfaceBuilder.CocoaPlugin" version="10117"/>
+    </dependencies>
+    <scenes>
+        <!--Application-->
+        <scene sceneID="JPo-4y-FX3">
+            <objects>
+                <application id="hnw-xV-0zn" sceneMemberID="viewController">
+                    <menu key="mainMenu" title="Main Menu" systemMenu="main" id="AYu-sK-qS6">
+                        <items>
+                            <menuItem title="VkCubepp" id="1Xt-HY-uBw">
+                                <modifierMask key="keyEquivalentModifierMask"/>
+                                <menu key="submenu" title="VkCubepp" systemMenu="apple" id="uQy-DD-JDr">
+                                    <items>
+                                        <menuItem title="About Demo" id="5kV-Vb-QxS">
+                                            <modifierMask key="keyEquivalentModifierMask"/>
+                                            <connections>
+                                                <action selector="orderFrontStandardAboutPanel:" target="Ady-hI-5gd" id="Exp-CZ-Vem"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem isSeparatorItem="YES" id="VOq-y0-SEH"/>
+                                        <menuItem title="Hide Demo" keyEquivalent="h" id="Olw-nP-bQN">
+                                            <connections>
+                                                <action selector="hide:" target="Ady-hI-5gd" id="PnN-Uc-m68"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem title="Hide Others" keyEquivalent="h" id="Vdr-fp-XzO">
+                                            <modifierMask key="keyEquivalentModifierMask" option="YES" command="YES"/>
+                                            <connections>
+                                                <action selector="hideOtherApplications:" target="Ady-hI-5gd" id="VT4-aY-XCT"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem title="Show All" id="Kd2-mp-pUS">
+                                            <modifierMask key="keyEquivalentModifierMask"/>
+                                            <connections>
+                                                <action selector="unhideAllApplications:" target="Ady-hI-5gd" id="Dhg-Le-xox"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem isSeparatorItem="YES" id="kCx-OE-vgT"/>
+                                        <menuItem title="Quit Demo" keyEquivalent="q" id="4sb-4s-VLi">
+                                            <connections>
+                                                <action selector="terminate:" target="Ady-hI-5gd" id="Te7-pn-YzF"/>
+                                            </connections>
+                                        </menuItem>
+                                    </items>
+                                </menu>
+                            </menuItem>
+                            <menuItem title="Window" id="aUF-d1-5bR">
+                                <modifierMask key="keyEquivalentModifierMask"/>
+                                <menu key="submenu" title="Window" systemMenu="window" id="Td7-aD-5lo">
+                                    <items>
+                                        <menuItem title="Minimize" keyEquivalent="m" id="OY7-WF-poV">
+                                            <connections>
+                                                <action selector="performMiniaturize:" target="Ady-hI-5gd" id="VwT-WD-YPe"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem title="Zoom" id="R4o-n2-Eq4">
+                                            <modifierMask key="keyEquivalentModifierMask"/>
+                                            <connections>
+                                                <action selector="performZoom:" target="Ady-hI-5gd" id="DIl-cC-cCs"/>
+                                            </connections>
+                                        </menuItem>
+                                        <menuItem isSeparatorItem="YES" id="eu3-7i-yIM"/>
+                                        <menuItem title="Bring All to Front" id="LE2-aR-0XJ">
+                                            <modifierMask key="keyEquivalentModifierMask"/>
+                                            <connections>
+                                                <action selector="arrangeInFront:" target="Ady-hI-5gd" id="DRN-fu-gQh"/>
+                                            </connections>
+                                        </menuItem>
+                                    </items>
+                                </menu>
+                            </menuItem>
+                            <menuItem title="Help" id="wpr-3q-Mcd">
+                                <modifierMask key="keyEquivalentModifierMask"/>
+                                <menu key="submenu" title="Help" systemMenu="help" id="F2S-fz-NVQ">
+                                    <items>
+                                        <menuItem title="VkCubepp Help" keyEquivalent="?" id="FKE-Sm-Kum">
+                                            <connections>
+                                                <action selector="showHelp:" target="Ady-hI-5gd" id="y7X-2Q-9no"/>
+                                            </connections>
+                                        </menuItem>
+                                    </items>
+                                </menu>
+                            </menuItem>
+                        </items>
+                    </menu>
+                    <connections>
+                        <outlet property="delegate" destination="Voe-Tx-rLC" id="PrD-fu-P6m"/>
+                    </connections>
+                </application>
+                <customObject id="Voe-Tx-rLC" customClass="AppDelegate"/>
+                <customObject id="Ady-hI-5gd" userLabel="First Responder" customClass="NSResponder" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="83.5" y="-47"/>
+        </scene>
+        <!--Window Controller-->
+        <scene sceneID="R2V-B0-nI4">
+            <objects>
+                <windowController id="B8D-0N-5wS" sceneMemberID="viewController">
+                    <window key="window" title="VkCubepp" allowsToolTipsWhenApplicationIsInactive="NO" autorecalculatesKeyViewLoop="NO" oneShot="NO" releasedWhenClosed="NO" showsToolbarButton="NO" visibleAtLaunch="NO" animationBehavior="default" id="IQv-IB-iLA">
+                        <windowStyleMask key="styleMask" titled="YES" closable="YES" miniaturizable="YES" resizable="YES"/>
+                        <rect key="contentRect" x="1051" y="656" width="300" height="200"/>
+                        <rect key="screenRect" x="0.0" y="0.0" width="2560" height="1417"/>
+                        <value key="minSize" type="size" width="300" height="200"/>
+                    </window>
+                    <connections>
+                        <segue destination="XfG-lQ-9wD" kind="relationship" relationship="window.shadowedContentViewController" id="cq2-FE-JQM"/>
+                    </connections>
+                </windowController>
+                <customObject id="Oky-zY-oP4" userLabel="First Responder" customClass="NSResponder" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="83" y="146"/>
+        </scene>
+        <!--Demo View Controller-->
+        <scene sceneID="hIz-AP-VOD">
+            <objects>
+                <viewController id="XfG-lQ-9wD" customClass="DemoViewController" sceneMemberID="viewController">
+                    <view key="view" id="m2S-Jp-Qdl" customClass="DemoView">
+                        <rect key="frame" x="0.0" y="0.0" width="400" height="300"/>
+                        <autoresizingMask key="autoresizingMask"/>
+                    </view>
+                </viewController>
+                <customObject id="rPt-NT-nkU" userLabel="First Responder" customClass="NSResponder" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="83" y="564"/>
+        </scene>
+    </scenes>
+</document>
diff --git a/tools/Vulkan-Tools/cube/macOS/cubepp/Resources/VulkanIcon.icns b/tools/Vulkan-Tools/cube/macOS/cubepp/Resources/VulkanIcon.icns
new file mode 100644
index 00000000..fb82fb7d
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/macOS/cubepp/Resources/VulkanIcon.icns
diff --git a/tools/Vulkan-Tools/cube/macOS/cubepp/main.mm b/tools/Vulkan-Tools/cube/macOS/cubepp/main.mm
new file mode 100644
index 00000000..cf9e0d89
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/macOS/cubepp/main.mm
@@ -0,0 +1,21 @@
+/*
+ * main.m
+ *
+ * Copyright (c) 2014-2018 The Brenwill Workshop Ltd. (http://www.brenwill.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <Cocoa/Cocoa.h>
+
+int main(int argc, const char* argv[]) { return NSApplicationMain(argc, argv); }
diff --git a/tools/Vulkan-Tools/cube/object_type_string_helper.h b/tools/Vulkan-Tools/cube/object_type_string_helper.h
new file mode 100644
index 00000000..0469b801
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/object_type_string_helper.h
@@ -0,0 +1,107 @@
+/***************************************************************************
+ *
+ * Copyright (c) 2018 The Khronos Group Inc.
+ * Copyright (c) 2018 Valve Corporation
+ * Copyright (c) 2018 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Mark Lobodzinski <mark@lunarg.com>
+ *
+ ****************************************************************************/
+
+#pragma once
+#ifdef _MSC_VER
+#pragma warning(disable : 4065)
+#endif
+
+#include <vulkan/vulkan.h>
+
+static inline const char* string_VkObjectType(VkObjectType input_value) {
+    switch ((VkObjectType)input_value) {
+        case VK_OBJECT_TYPE_QUERY_POOL:
+            return "VK_OBJECT_TYPE_QUERY_POOL";
+        case VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION:
+            return "VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION";
+        case VK_OBJECT_TYPE_SEMAPHORE:
+            return "VK_OBJECT_TYPE_SEMAPHORE";
+        case VK_OBJECT_TYPE_SHADER_MODULE:
+            return "VK_OBJECT_TYPE_SHADER_MODULE";
+        case VK_OBJECT_TYPE_SWAPCHAIN_KHR:
+            return "VK_OBJECT_TYPE_SWAPCHAIN_KHR";
+        case VK_OBJECT_TYPE_SAMPLER:
+            return "VK_OBJECT_TYPE_SAMPLER";
+        case VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV:
+            return "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV";
+        case VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT:
+            return "VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT";
+        case VK_OBJECT_TYPE_IMAGE:
+            return "VK_OBJECT_TYPE_IMAGE";
+        case VK_OBJECT_TYPE_UNKNOWN:
+            return "VK_OBJECT_TYPE_UNKNOWN";
+        case VK_OBJECT_TYPE_DESCRIPTOR_POOL:
+            return "VK_OBJECT_TYPE_DESCRIPTOR_POOL";
+        case VK_OBJECT_TYPE_COMMAND_BUFFER:
+            return "VK_OBJECT_TYPE_COMMAND_BUFFER";
+        case VK_OBJECT_TYPE_BUFFER:
+            return "VK_OBJECT_TYPE_BUFFER";
+        case VK_OBJECT_TYPE_SURFACE_KHR:
+            return "VK_OBJECT_TYPE_SURFACE_KHR";
+        case VK_OBJECT_TYPE_INSTANCE:
+            return "VK_OBJECT_TYPE_INSTANCE";
+        case VK_OBJECT_TYPE_VALIDATION_CACHE_EXT:
+            return "VK_OBJECT_TYPE_VALIDATION_CACHE_EXT";
+        case VK_OBJECT_TYPE_IMAGE_VIEW:
+            return "VK_OBJECT_TYPE_IMAGE_VIEW";
+        case VK_OBJECT_TYPE_DESCRIPTOR_SET:
+            return "VK_OBJECT_TYPE_DESCRIPTOR_SET";
+        case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT:
+            return "VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT";
+        case VK_OBJECT_TYPE_COMMAND_POOL:
+            return "VK_OBJECT_TYPE_COMMAND_POOL";
+        case VK_OBJECT_TYPE_PHYSICAL_DEVICE:
+            return "VK_OBJECT_TYPE_PHYSICAL_DEVICE";
+        case VK_OBJECT_TYPE_DISPLAY_KHR:
+            return "VK_OBJECT_TYPE_DISPLAY_KHR";
+        case VK_OBJECT_TYPE_BUFFER_VIEW:
+            return "VK_OBJECT_TYPE_BUFFER_VIEW";
+        case VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT:
+            return "VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT";
+        case VK_OBJECT_TYPE_FRAMEBUFFER:
+            return "VK_OBJECT_TYPE_FRAMEBUFFER";
+        case VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE:
+            return "VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE";
+        case VK_OBJECT_TYPE_PIPELINE_CACHE:
+            return "VK_OBJECT_TYPE_PIPELINE_CACHE";
+        case VK_OBJECT_TYPE_PIPELINE_LAYOUT:
+            return "VK_OBJECT_TYPE_PIPELINE_LAYOUT";
+        case VK_OBJECT_TYPE_DEVICE_MEMORY:
+            return "VK_OBJECT_TYPE_DEVICE_MEMORY";
+        case VK_OBJECT_TYPE_FENCE:
+            return "VK_OBJECT_TYPE_FENCE";
+        case VK_OBJECT_TYPE_QUEUE:
+            return "VK_OBJECT_TYPE_QUEUE";
+        case VK_OBJECT_TYPE_DEVICE:
+            return "VK_OBJECT_TYPE_DEVICE";
+        case VK_OBJECT_TYPE_RENDER_PASS:
+            return "VK_OBJECT_TYPE_RENDER_PASS";
+        case VK_OBJECT_TYPE_DISPLAY_MODE_KHR:
+            return "VK_OBJECT_TYPE_DISPLAY_MODE_KHR";
+        case VK_OBJECT_TYPE_EVENT:
+            return "VK_OBJECT_TYPE_EVENT";
+        case VK_OBJECT_TYPE_PIPELINE:
+            return "VK_OBJECT_TYPE_PIPELINE";
+        default:
+            return "Unhandled VkObjectType";
+    }
+}
diff --git a/tools/Vulkan-Tools/cube/wayland_loader.h b/tools/Vulkan-Tools/cube/wayland_loader.h
new file mode 100644
index 00000000..7d7d9141
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/wayland_loader.h
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2024 The Khronos Group Inc.
+ * Copyright (c) 2024 Valve Corporation
+ * Copyright (c) 2024 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Charles Giessen <charles@lunarg.com>
+ */
+
+#pragma once
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <dlfcn.h>
+
+#include <wayland-client-core.h>
+
+typedef struct wl_display *(*PFN_wl_display_connect)(const char *name);
+typedef int (*PFN_wl_display_flush)(struct wl_display *display);
+typedef int (*PFN_wl_display_dispatch)(struct wl_display *display);
+typedef int (*PFN_wl_display_prepare_read)(struct wl_display *display);
+typedef int (*PFN_wl_display_dispatch_pending)(struct wl_display *display);
+typedef int (*PFN_wl_display_read_events)(struct wl_display *display);
+typedef void (*PFN_wl_proxy_marshal)(struct wl_proxy *p, uint32_t opcode, ...);
+typedef struct wl_proxy *(*PFN_wl_proxy_marshal_constructor)(struct wl_proxy *proxy, uint32_t opcode,
+                                                             const struct wl_interface *interface, ...);
+typedef struct wl_proxy *(*PFN_wl_proxy_marshal_constructor_versioned)(struct wl_proxy *proxy, uint32_t opcode,
+                                                                       const struct wl_interface *interface, uint32_t version, ...);
+typedef struct wl_proxy *(*PFN_wl_proxy_marshal_flags)(struct wl_proxy *proxy, uint32_t opcode,
+                                                       const struct wl_interface *interface, uint32_t version, uint32_t flags, ...);
+typedef uint32_t (*PFN_wl_proxy_get_version)(struct wl_proxy *proxy);
+typedef int (*PFN_wl_proxy_add_listener)(struct wl_proxy *proxy, void (**implementation)(void), void *data);
+typedef void (*PFN_wl_proxy_destroy)(struct wl_proxy *proxy);
+typedef int (*PFN_wl_display_roundtrip)(struct wl_display *display);
+typedef void (*PFN_wl_display_disconnect)(struct wl_display *display);
+
+static PFN_wl_display_connect cube_wl_display_connect = NULL;
+static PFN_wl_display_flush cube_wl_display_flush = NULL;
+static PFN_wl_display_dispatch cube_wl_display_dispatch = NULL;
+static PFN_wl_display_prepare_read cube_wl_display_prepare_read = NULL;
+static PFN_wl_display_dispatch_pending cube_wl_display_dispatch_pending = NULL;
+static PFN_wl_display_read_events cube_wl_display_read_events = NULL;
+static PFN_wl_proxy_marshal cube_wl_proxy_marshal = NULL;
+static PFN_wl_proxy_marshal_constructor cube_wl_proxy_marshal_constructor = NULL;
+static PFN_wl_proxy_marshal_constructor_versioned cube_wl_proxy_marshal_constructor_versioned = NULL;
+static PFN_wl_proxy_marshal_flags cube_wl_proxy_marshal_flags = NULL;
+static PFN_wl_proxy_get_version cube_wl_proxy_get_version = NULL;
+static PFN_wl_proxy_add_listener cube_wl_proxy_add_listener = NULL;
+static PFN_wl_proxy_destroy cube_wl_proxy_destroy = NULL;
+static PFN_wl_display_roundtrip cube_wl_display_roundtrip = NULL;
+static PFN_wl_display_disconnect cube_wl_display_disconnect = NULL;
+
+// Use macro's to redefine the PFN's as the functions in client code
+#define wl_display_connect cube_wl_display_connect
+#define wl_display_flush cube_wl_display_flush
+#define wl_display_dispatch cube_wl_display_dispatch
+#define wl_display_prepare_read cube_wl_display_prepare_read
+#define wl_display_dispatch_pending cube_wl_display_dispatch_pending
+#define wl_display_read_events cube_wl_display_read_events
+#define wl_proxy_marshal cube_wl_proxy_marshal
+#define wl_proxy_marshal_constructor cube_wl_proxy_marshal_constructor
+#define wl_proxy_marshal_constructor_versioned cube_wl_proxy_marshal_constructor_versioned
+#define wl_proxy_marshal_flags cube_wl_proxy_marshal_flags
+#define wl_proxy_get_version cube_wl_proxy_get_version
+#define wl_proxy_add_listener cube_wl_proxy_add_listener
+#define wl_proxy_destroy cube_wl_proxy_destroy
+#define wl_display_roundtrip cube_wl_display_roundtrip
+#define wl_display_disconnect cube_wl_display_disconnect
+
+static inline void *initialize_wayland() {
+    void *wayland_library = NULL;
+    if (NULL == wayland_library) {
+        wayland_library = dlopen("libwayland-client.so.0", RTLD_NOW | RTLD_LOCAL);
+    }
+    if (NULL == wayland_library) {
+        wayland_library = dlopen("libwayland-client.so", RTLD_NOW | RTLD_LOCAL);
+    }
+    if (NULL == wayland_library) {
+        return NULL;
+    }
+
+#ifdef __cplusplus
+#define TYPE_CONVERSION(type) reinterpret_cast<type>
+#else
+#define TYPE_CONVERSION(type)
+#endif
+    cube_wl_display_connect = TYPE_CONVERSION(PFN_wl_display_connect)(dlsym(wayland_library, "wl_display_connect"));
+    cube_wl_display_flush = TYPE_CONVERSION(PFN_wl_display_flush)(dlsym(wayland_library, "wl_display_flush"));
+    cube_wl_display_dispatch = TYPE_CONVERSION(PFN_wl_display_dispatch)(dlsym(wayland_library, "wl_display_dispatch"));
+    cube_wl_display_prepare_read = TYPE_CONVERSION(PFN_wl_display_prepare_read)(dlsym(wayland_library, "wl_display_prepare_read"));
+    cube_wl_display_dispatch_pending =
+        TYPE_CONVERSION(PFN_wl_display_dispatch_pending)(dlsym(wayland_library, "wl_display_dispatch_pending"));
+    cube_wl_display_read_events = TYPE_CONVERSION(PFN_wl_display_read_events)(dlsym(wayland_library, "wl_display_read_events"));
+    cube_wl_proxy_marshal = TYPE_CONVERSION(PFN_wl_proxy_marshal)(dlsym(wayland_library, "wl_proxy_marshal"));
+    cube_wl_proxy_marshal_constructor =
+        TYPE_CONVERSION(PFN_wl_proxy_marshal_constructor)(dlsym(wayland_library, "wl_proxy_marshal_constructor"));
+    cube_wl_proxy_marshal_constructor_versioned = TYPE_CONVERSION(PFN_wl_proxy_marshal_constructor_versioned)(
+        dlsym(wayland_library, "wl_proxy_marshal_constructor_versioned"));
+    cube_wl_proxy_marshal_flags = TYPE_CONVERSION(PFN_wl_proxy_marshal_flags)(dlsym(wayland_library, "wl_proxy_marshal_flags"));
+    cube_wl_proxy_get_version = TYPE_CONVERSION(PFN_wl_proxy_get_version)(dlsym(wayland_library, "wl_proxy_get_version"));
+    cube_wl_proxy_add_listener = TYPE_CONVERSION(PFN_wl_proxy_add_listener)(dlsym(wayland_library, "wl_proxy_add_listener"));
+    cube_wl_proxy_destroy = TYPE_CONVERSION(PFN_wl_proxy_destroy)(dlsym(wayland_library, "wl_proxy_destroy"));
+    cube_wl_display_roundtrip = TYPE_CONVERSION(PFN_wl_display_roundtrip)(dlsym(wayland_library, "wl_display_roundtrip"));
+    cube_wl_display_disconnect = TYPE_CONVERSION(PFN_wl_display_disconnect)(dlsym(wayland_library, "wl_display_disconnect"));
+
+    return wayland_library;
+}
+
+#include "xdg-shell-client-header.h"
+#include "xdg-decoration-client-header.h"
diff --git a/tools/Vulkan-Tools/cube/xcb_loader.h b/tools/Vulkan-Tools/cube/xcb_loader.h
new file mode 100644
index 00000000..cecd2540
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/xcb_loader.h
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2024 The Khronos Group Inc.
+ * Copyright (c) 2024 Valve Corporation
+ * Copyright (c) 2024 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Charles Giessen <charles@lunarg.com>
+ */
+
+#pragma once
+
+#include <dlfcn.h>
+#include <stdlib.h>
+
+#include <xcb/xcb.h>
+
+typedef xcb_void_cookie_t (*PFN_xcb_destroy_window)(xcb_connection_t *c, xcb_window_t window);
+typedef void (*PFN_xcb_disconnect)(xcb_connection_t *c);
+typedef int (*PFN_xcb_flush)(xcb_connection_t *c);
+typedef xcb_generic_event_t *(*PFN_xcb_wait_for_event)(xcb_connection_t *c);
+typedef xcb_generic_event_t *(*PFN_xcb_poll_for_event)(xcb_connection_t *c);
+typedef uint32_t (*PFN_xcb_generate_id)(xcb_connection_t *c);
+typedef xcb_void_cookie_t (*PFN_xcb_create_window)(xcb_connection_t *c, uint8_t depth, xcb_window_t wid, xcb_window_t parent,
+                                                   int16_t x, int16_t y, uint16_t width, uint16_t height, uint16_t border_width,
+                                                   uint16_t _class, xcb_visualid_t visual, uint32_t value_mask,
+                                                   const void *value_list);
+typedef xcb_intern_atom_cookie_t (*PFN_xcb_intern_atom)(xcb_connection_t *c, uint8_t only_if_exists, uint16_t name_len,
+                                                        const char *name);
+typedef xcb_intern_atom_reply_t *(*PFN_xcb_intern_atom_reply)(xcb_connection_t *c, xcb_intern_atom_cookie_t cookie /**< */,
+                                                              xcb_generic_error_t **e);
+typedef xcb_void_cookie_t (*PFN_xcb_change_property)(xcb_connection_t *c, uint8_t mode, xcb_window_t window, xcb_atom_t property,
+                                                     xcb_atom_t type, uint8_t format, uint32_t data_len, const void *data);
+typedef xcb_void_cookie_t (*PFN_xcb_map_window)(xcb_connection_t *c, xcb_window_t window);
+typedef xcb_void_cookie_t (*PFN_xcb_configure_window)(xcb_connection_t *c, xcb_window_t window, uint16_t value_mask,
+                                                      const void *value_list);
+typedef xcb_connection_t *(*PFN_xcb_connect)(const char *displayname, int *screenp);
+typedef int (*PFN_xcb_connection_has_error)(xcb_connection_t *c);
+typedef const struct xcb_setup_t *(*PFN_xcb_get_setup)(xcb_connection_t *c);
+typedef xcb_screen_iterator_t (*PFN_xcb_setup_roots_iterator)(const xcb_setup_t *R);
+typedef void (*PFN_xcb_screen_next)(xcb_screen_iterator_t *i);
+
+static PFN_xcb_destroy_window cube_xcb_destroy_window = NULL;
+static PFN_xcb_disconnect cube_xcb_disconnect = NULL;
+static PFN_xcb_flush cube_xcb_flush = NULL;
+static PFN_xcb_wait_for_event cube_xcb_wait_for_event = NULL;
+static PFN_xcb_poll_for_event cube_xcb_poll_for_event = NULL;
+static PFN_xcb_generate_id cube_xcb_generate_id = NULL;
+static PFN_xcb_create_window cube_xcb_create_window = NULL;
+static PFN_xcb_intern_atom cube_xcb_intern_atom = NULL;
+static PFN_xcb_intern_atom_reply cube_xcb_intern_atom_reply = NULL;
+static PFN_xcb_change_property cube_xcb_change_property = NULL;
+static PFN_xcb_map_window cube_xcb_map_window = NULL;
+static PFN_xcb_configure_window cube_xcb_configure_window = NULL;
+static PFN_xcb_connect cube_xcb_connect = NULL;
+static PFN_xcb_connection_has_error cube_xcb_connection_has_error = NULL;
+static PFN_xcb_get_setup cube_xcb_get_setup = NULL;
+static PFN_xcb_setup_roots_iterator cube_xcb_setup_roots_iterator = NULL;
+static PFN_xcb_screen_next cube_xcb_screen_next = NULL;
+
+#define xcb_destroy_window cube_xcb_destroy_window
+#define xcb_disconnect cube_xcb_disconnect
+#define xcb_flush cube_xcb_flush
+#define xcb_wait_for_event cube_xcb_wait_for_event
+#define xcb_poll_for_event cube_xcb_poll_for_event
+#define xcb_generate_id cube_xcb_generate_id
+#define xcb_create_window cube_xcb_create_window
+#define xcb_intern_atom cube_xcb_intern_atom
+#define xcb_intern_atom_reply cube_xcb_intern_atom_reply
+#define xcb_change_property cube_xcb_change_property
+#define xcb_map_window cube_xcb_map_window
+#define xcb_configure_window cube_xcb_configure_window
+#define xcb_connect cube_xcb_connect
+#define xcb_connection_has_error cube_xcb_connection_has_error
+#define xcb_get_setup cube_xcb_get_setup
+#define xcb_setup_roots_iterator cube_xcb_setup_roots_iterator
+#define xcb_screen_next cube_xcb_screen_next
+
+void *initialize_xcb() {
+    void *xcb_library = NULL;
+    if (NULL == xcb_library) {
+        xcb_library = dlopen("libxcb.so.1", RTLD_NOW | RTLD_LOCAL);
+    }
+    if (NULL == xcb_library) {
+        xcb_library = dlopen("libxcb.so", RTLD_NOW | RTLD_LOCAL);
+    }
+    if (NULL == xcb_library) {
+        return NULL;
+    }
+
+#ifdef __cplusplus
+#define TYPE_CONVERSION(type) reinterpret_cast<type>
+#else
+#define TYPE_CONVERSION(type)
+#endif
+
+    cube_xcb_destroy_window = TYPE_CONVERSION(PFN_xcb_destroy_window)(dlsym(xcb_library, "xcb_destroy_window"));
+    cube_xcb_disconnect = TYPE_CONVERSION(PFN_xcb_disconnect)(dlsym(xcb_library, "xcb_disconnect"));
+    cube_xcb_flush = TYPE_CONVERSION(PFN_xcb_flush)(dlsym(xcb_library, "xcb_flush"));
+    cube_xcb_wait_for_event = TYPE_CONVERSION(PFN_xcb_wait_for_event)(dlsym(xcb_library, "xcb_wait_for_event"));
+    cube_xcb_poll_for_event = TYPE_CONVERSION(PFN_xcb_poll_for_event)(dlsym(xcb_library, "xcb_poll_for_event"));
+    cube_xcb_generate_id = TYPE_CONVERSION(PFN_xcb_generate_id)(dlsym(xcb_library, "xcb_generate_id"));
+    cube_xcb_create_window = TYPE_CONVERSION(PFN_xcb_create_window)(dlsym(xcb_library, "xcb_create_window"));
+    cube_xcb_intern_atom = TYPE_CONVERSION(PFN_xcb_intern_atom)(dlsym(xcb_library, "xcb_intern_atom"));
+    cube_xcb_intern_atom_reply = TYPE_CONVERSION(PFN_xcb_intern_atom_reply)(dlsym(xcb_library, "xcb_intern_atom_reply"));
+    cube_xcb_change_property = TYPE_CONVERSION(PFN_xcb_change_property)(dlsym(xcb_library, "xcb_change_property"));
+    cube_xcb_map_window = TYPE_CONVERSION(PFN_xcb_map_window)(dlsym(xcb_library, "xcb_map_window"));
+    cube_xcb_configure_window = TYPE_CONVERSION(PFN_xcb_configure_window)(dlsym(xcb_library, "xcb_configure_window"));
+    cube_xcb_connect = TYPE_CONVERSION(PFN_xcb_connect)(dlsym(xcb_library, "xcb_connect"));
+    cube_xcb_connection_has_error = TYPE_CONVERSION(PFN_xcb_connection_has_error)(dlsym(xcb_library, "xcb_connection_has_error"));
+    cube_xcb_get_setup = TYPE_CONVERSION(PFN_xcb_get_setup)(dlsym(xcb_library, "xcb_get_setup"));
+    cube_xcb_setup_roots_iterator = TYPE_CONVERSION(PFN_xcb_setup_roots_iterator)(dlsym(xcb_library, "xcb_setup_roots_iterator"));
+    cube_xcb_screen_next = TYPE_CONVERSION(PFN_xcb_screen_next)(dlsym(xcb_library, "xcb_screen_next"));
+
+    return xcb_library;
+}
diff --git a/tools/Vulkan-Tools/cube/xlib_loader.h b/tools/Vulkan-Tools/cube/xlib_loader.h
new file mode 100644
index 00000000..5553558d
--- /dev/null
+++ b/tools/Vulkan-Tools/cube/xlib_loader.h
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2024 The Khronos Group Inc.
+ * Copyright (c) 2024 Valve Corporation
+ * Copyright (c) 2024 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Charles Giessen <charles@lunarg.com>
+ */
+
+#pragma once
+
+#include <dlfcn.h>
+#include <stdlib.h>
+
+#include <X11/Xutil.h>
+
+typedef int (*PFN_XDestroyWindow)(Display*, Window);
+typedef Display* (*PFN_XOpenDisplay)(_Xconst char*);
+typedef Colormap (*PFN_XCreateColormap)(Display*, Window, Visual*, int);
+typedef Window (*PFN_XCreateWindow)(Display*, Window, int, int, unsigned int, unsigned int, unsigned int, int, unsigned int,
+                                    Visual*, unsigned long, XSetWindowAttributes*);
+typedef int (*PFN_XSelectInput)(Display*, Window, long);
+typedef int (*PFN_XMapWindow)(Display*, Window);
+typedef Atom (*PFN_XInternAtom)(Display*, _Xconst char*, Bool);
+typedef int (*PFN_XNextEvent)(Display*, XEvent*);
+typedef int (*PFN_XPending)(Display*);
+typedef XVisualInfo* (*PFN_XGetVisualInfo)(Display*, long, XVisualInfo*, int*);
+typedef int (*PFN_XCloseDisplay)(Display* /* display */
+);
+typedef Status (*PFN_XInitThreads)(void);
+typedef int (*PFN_XFlush)(Display* /* display */
+);
+typedef Status (*PFN_XSetWMProtocols)(Display*, Window, Atom*, int);
+
+static PFN_XDestroyWindow cube_XDestroyWindow = NULL;
+static PFN_XOpenDisplay cube_XOpenDisplay = NULL;
+static PFN_XCreateColormap cube_XCreateColormap = NULL;
+static PFN_XCreateWindow cube_XCreateWindow = NULL;
+static PFN_XSelectInput cube_XSelectInput = NULL;
+static PFN_XMapWindow cube_XMapWindow = NULL;
+static PFN_XInternAtom cube_XInternAtom = NULL;
+static PFN_XNextEvent cube_XNextEvent = NULL;
+static PFN_XPending cube_XPending = NULL;
+static PFN_XGetVisualInfo cube_XGetVisualInfo = NULL;
+static PFN_XCloseDisplay cube_XCloseDisplay = NULL;
+static PFN_XInitThreads cube_XInitThreads = NULL;
+static PFN_XFlush cube_XFlush = NULL;
+static PFN_XSetWMProtocols cube_XSetWMProtocols = NULL;
+
+#define XDestroyWindow cube_XDestroyWindow
+#define XOpenDisplay cube_XOpenDisplay
+#define XCreateColormap cube_XCreateColormap
+#define XCreateWindow cube_XCreateWindow
+#define XSelectInput cube_XSelectInput
+#define XMapWindow cube_XMapWindow
+#define XInternAtom cube_XInternAtom
+#define XNextEvent cube_XNextEvent
+#define XPending cube_XPending
+#define XGetVisualInfo cube_XGetVisualInfo
+#define XCloseDisplay cube_XCloseDisplay
+#define XInitThreads cube_XInitThreads
+#define XFlush cube_XFlush
+#define XSetWMProtocols cube_XSetWMProtocols
+
+void* initialize_xlib() {
+    void* xlib_library = NULL;
+    if (NULL == xlib_library) {
+        xlib_library = dlopen("libX11.so.6", RTLD_NOW | RTLD_LOCAL);
+    }
+    if (NULL == xlib_library) {
+        xlib_library = dlopen("libX11.so", RTLD_NOW | RTLD_LOCAL);
+    }
+    if (NULL == xlib_library) {
+        return NULL;
+    }
+
+#ifdef __cplusplus
+#define TYPE_CONVERSION(type) reinterpret_cast<type>
+#else
+#define TYPE_CONVERSION(type)
+#endif
+
+    cube_XDestroyWindow = TYPE_CONVERSION(PFN_XDestroyWindow)(dlsym(xlib_library, "XDestroyWindow"));
+    cube_XOpenDisplay = TYPE_CONVERSION(PFN_XOpenDisplay)(dlsym(xlib_library, "XOpenDisplay"));
+    cube_XCreateColormap = TYPE_CONVERSION(PFN_XCreateColormap)(dlsym(xlib_library, "XCreateColormap"));
+    cube_XCreateWindow = TYPE_CONVERSION(PFN_XCreateWindow)(dlsym(xlib_library, "XCreateWindow"));
+    cube_XSelectInput = TYPE_CONVERSION(PFN_XSelectInput)(dlsym(xlib_library, "XSelectInput"));
+    cube_XMapWindow = TYPE_CONVERSION(PFN_XMapWindow)(dlsym(xlib_library, "XMapWindow"));
+    cube_XInternAtom = TYPE_CONVERSION(PFN_XInternAtom)(dlsym(xlib_library, "XInternAtom"));
+    cube_XNextEvent = TYPE_CONVERSION(PFN_XNextEvent)(dlsym(xlib_library, "XNextEvent"));
+    cube_XPending = TYPE_CONVERSION(PFN_XPending)(dlsym(xlib_library, "XPending"));
+    cube_XGetVisualInfo = TYPE_CONVERSION(PFN_XGetVisualInfo)(dlsym(xlib_library, "XGetVisualInfo"));
+    cube_XCloseDisplay = TYPE_CONVERSION(PFN_XCloseDisplay)(dlsym(xlib_library, "XCloseDisplay"));
+    cube_XInitThreads = TYPE_CONVERSION(PFN_XInitThreads)(dlsym(xlib_library, "XInitThreads"));
+    cube_XFlush = TYPE_CONVERSION(PFN_XFlush)(dlsym(xlib_library, "XFlush"));
+    cube_XSetWMProtocols = TYPE_CONVERSION(PFN_XSetWMProtocols)(dlsym(xlib_library, "XSetWMProtocols"));
+
+    return xlib_library;
+}
diff --git a/tools/Vulkan-Tools/icd/CMakeLists.txt b/tools/Vulkan-Tools/icd/CMakeLists.txt
new file mode 100644
index 00000000..a66d9c9d
--- /dev/null
+++ b/tools/Vulkan-Tools/icd/CMakeLists.txt
@@ -0,0 +1,148 @@
+# ~~~
+# Copyright (c) 2014-2018 Valve Corporation
+# Copyright (c) 2014-2018 LunarG, Inc.
+# Copyright (c) 2023-2023 RasterGrid Kft.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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 (ANDROID OR MINGW)
+    return()
+endif()
+
+# These variables enable downstream users to customize the CMake targets
+# based on the target API variant (e.g. Vulkan SC)
+set(MOCK_ICD_NAME VkICD_mock_icd)
+set(GENERATED generated)
+
+option(BUILD_MOCK_ANDROID_SUPPORT "Build with Android Platform headers" OFF)
+
+if(WIN32)
+    add_definitions(-DVK_USE_PLATFORM_WIN32_KHR -DVK_USE_PLATFORM_WIN32_KHX -DWIN32_LEAN_AND_MEAN)
+elseif(APPLE)
+    add_definitions(-DVK_USE_PLATFORM_METAL_EXT)
+    if (IOS)
+        add_definitions(-DVK_USE_PLATFORM_IOS_MVK)
+    else()
+        add_definitions(-DVK_USE_PLATFORM_MACOS_MVK)
+    endif()
+elseif(BUILD_MOCK_ANDROID_SUPPORT)
+    add_definitions(-DVK_USE_PLATFORM_ANDROID_KHR)
+elseif(CMAKE_SYSTEM_NAME MATCHES "Linux|BSD|GNU")
+    if(BUILD_WSI_XCB_SUPPORT)
+        add_definitions(-DVK_USE_PLATFORM_XCB_KHR -DVK_USE_PLATFORM_XCB_KHX)
+    endif()
+
+    if(BUILD_WSI_XLIB_SUPPORT)
+        add_definitions(-DVK_USE_PLATFORM_XLIB_KHR -DVK_USE_PLATFORM_XLIB_KHX -DVK_USE_PLATFORM_XLIB_XRANDR_EXT)
+    endif()
+
+    if(BUILD_WSI_WAYLAND_SUPPORT)
+        add_definitions(-DVK_USE_PLATFORM_WAYLAND_KHR -DVK_USE_PLATFORM_WAYLAND_KHX)
+    endif()
+else()
+    message(FATAL_ERROR "Unsupported Platform!")
+endif()
+
+add_library(VkICD_mock_icd MODULE)
+target_sources(VkICD_mock_icd PRIVATE mock_icd.cpp)
+target_link_libraries(VkICD_mock_icd PRIVATE Vulkan::Headers)
+
+target_include_directories(VkICD_mock_icd PRIVATE
+    ${GENERATED}
+    .
+)
+
+if(${CMAKE_CXX_COMPILER_ID} MATCHES "GNU|Clang")
+    target_compile_options(VkICD_mock_icd PRIVATE
+        -Wpointer-arith
+        -Wno-unused-function
+        -Wno-sign-compare
+    )
+endif()
+
+if(MSVC)
+    target_compile_options(VkICD_mock_icd PRIVATE /bigobj)
+    target_compile_definitions(VkICD_mock_icd PRIVATE _CRT_SECURE_NO_WARNINGS)
+    target_link_options(VkICD_mock_icd PRIVATE /DEF:${CMAKE_CURRENT_SOURCE_DIR}/${MOCK_ICD_NAME}.def)
+else()
+    if(APPLE)
+        set_target_properties(VkICD_mock_icd PROPERTIES SUFFIX ".dylib")
+    endif()
+    message(DEBUG "Mock ICD Functions are exported via EXPORT")
+endif()
+
+set_target_properties(VkICD_mock_icd PROPERTIES OUTPUT_NAME ${MOCK_ICD_NAME})
+
+if (DEFINED GIT_BRANCH_NAME AND DEFINED GIT_TAG_INFO)
+    target_compile_definitions(VkICD_mock_icd PRIVATE GIT_BRANCH_NAME="${GIT_BRANCH_NAME}" GIT_TAG_INFO="${GIT_TAG_INFO}")
+endif()
+
+# There are 2 primary deliverables for the mock driver.
+# - The actual library (lib)VkICD_mock_icd.(dll|so|dylib)
+# - The respective json file, VkICD_mock_icd.json
+# This code generates the appropriate json for both local testing and the installation.
+# NOTE: For WIN32 the JSON and dll MUST be placed in the same location, due to Win32 using a relative path for installation.
+set(INPUT_FILE "${CMAKE_CURRENT_SOURCE_DIR}/${MOCK_ICD_NAME}.json.in")
+set(INTERMEDIATE_FILE "${CMAKE_CURRENT_BINARY_DIR}/json/mock_icd.json")
+set(OUTPUT_FILE_FINAL_NAME "${MOCK_ICD_NAME}.json")
+set(LAYER_INSTALL_DIR ${CMAKE_INSTALL_LIBDIR})
+if (WIN32)
+    set(LAYER_INSTALL_DIR ${CMAKE_INSTALL_BINDIR}) # WIN32 expect the dll in the `bin` dir, this matches our WIN32 SDK process
+endif()
+
+if (WIN32)
+    set(JSON_LIBRARY_PATH ".\\\\${MOCK_ICD_NAME}.dll")
+elseif(APPLE)
+    set(JSON_LIBRARY_PATH "./lib${MOCK_ICD_NAME}.dylib")
+else()
+    set(JSON_LIBRARY_PATH "./lib${MOCK_ICD_NAME}.so")
+endif()
+
+configure_file(${INPUT_FILE} ${INTERMEDIATE_FILE} @ONLY)
+
+# To support both multi/single configuration generators just copy the json to the correct directory
+add_custom_command(TARGET VkICD_mock_icd POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different ${INTERMEDIATE_FILE} $<TARGET_FILE_DIR:VkICD_mock_icd>/${OUTPUT_FILE_FINAL_NAME}
+)
+
+# Installing the Mock ICD to system directories is probably not desired since this ICD is not a very complete implementation.
+# Require the user to ask that it be installed if they really want it.
+option(INSTALL_ICD "Install Mock icd")
+if (INSTALL_ICD)
+    message(NOTICE "INSTALL_ICD enabled!")
+else()
+    return()
+endif()
+
+# For UNIX-based systems, `library_path` should not contain a relative path (indicated by "./") before installing to system directories
+# This json isn't used for regular local development, it's used for installation
+if (UNIX)
+    set(UNIX_INTERMEDIATE_FILE "${CMAKE_CURRENT_BINARY_DIR}/json/unix_install_mock_icd.json")
+
+    if(APPLE)
+        set(JSON_LIBRARY_PATH "lib${MOCK_ICD_NAME}.dylib")
+    else()
+        set(JSON_LIBRARY_PATH "lib${MOCK_ICD_NAME}.so")
+    endif()
+
+    configure_file(${INPUT_FILE} ${UNIX_INTERMEDIATE_FILE} @ONLY)
+
+    install(FILES ${UNIX_INTERMEDIATE_FILE} DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/vulkan/icd.d RENAME ${OUTPUT_FILE_FINAL_NAME})
+endif()
+
+if (WIN32)
+    install(FILES ${INTERMEDIATE_FILE} DESTINATION ${LAYER_INSTALL_DIR} RENAME ${OUTPUT_FILE_FINAL_NAME})
+endif()
+
+install(TARGETS VkICD_mock_icd DESTINATION ${LAYER_INSTALL_DIR})
diff --git a/tools/Vulkan-Tools/icd/README.md b/tools/Vulkan-Tools/icd/README.md
new file mode 100644
index 00000000..1c6e6eae
--- /dev/null
+++ b/tools/Vulkan-Tools/icd/README.md
@@ -0,0 +1,80 @@
+# Vulkan Mock ICD
+
+This directory contains a mock ICD driver designed for validation layer testing.
+
+## Introduction
+
+The mock ICD is focused on enabling validation testing apart from an actual device. Because the validation layers
+sit on top of the ICD and don't depend upon the results of Vulkan rendering, they can be tested without having actual
+GPU hardware backing the ICD. The final mock driver will be composed of three main features: a null driver, flexible
+device configuration, and entrypoint tracking & verification.
+
+### Null Driver
+The intial mock driver features just the null driver capability. This allows all of the validation tests to be run
+on a fixed device configuration that is hard-coded into the ICD.
+
+### Entrypoint Tracking & Verification
+Entrypoint tracking and verification will be added to the mock layer as a later feature. The idea is that all expected
+Vulkan function calls and their parameters can be stored in the ICD and then a separate call can be made to verify that
+the exepected calls and parameters actually entered the ICD. This allows verification that the validation layers are
+correctly passing calls and their parameters through to the ICD unchanged.
+
+## Using the Mock ICD
+
+To enable the mock ICD, set VK\_ICD\_FILENAMES environment variable to point to your {BUILD_DIR}/icd/VkICD\_mock\_icd.json.
+
+## Plans
+
+The initial mock ICD is just the null driver which can be used to test validation layers on
+simulated devices. Here's a rough sequence of tasks planned for the mock driver going forward:
+- [X] Get all LVL tests passing on the bare null driver
+- [X] Get failing tests passing
+- [X] Get skipped tests passing as able
+- [ ] Get all LVL tests to run without unexpected errors
+- [X] Develop automated test flow using mock ICD (alternative to or replacement for run\_all\_tests.sh)
+- [ ] Update LVL tests with device dependencies to target specific device profiles
+- [ ] Add entrypoint tracking & verification
+- [ ] Initially track expected calls
+- [ ] Update some tests to verify expected capability
+- [ ] Expand tracking to include parameters
+
+## Beyond Validation Layer Testing
+
+The focus of the mock icd is for validation testing, but the code is available to use and enhance for anyone wishing to apply it for alternative
+purposes.
+With the following enhancements, the mock driver state available to the app should very closely mimic an actual ICD:
+- Update various function return codes
+- Simulated synchronization objects
+- Simulated query with mock data
+- Basic command buffer state tracking to note synch object transitions and query state updates
+
+Beyond that it's certainly possible that the mock icd could be hooked up to a SW renderer and serve as a virtual GPU with complete rendering/compute
+capabilities.
+
+## Status
+
+This is a temporary section used for tracking as the mock icd is being developed. Once all tests are passing with the mock, this section can be removed.
+Currently 333/333 tests are passing with the mock icd, but many passing tests have unexpected validation errors that need to be cleaned up.
+
+### Failing Tests
+
+NONE
+
+### Passing Tests With Unexpected Errors
+
+- VkLayerTest.RenderPassInUseDestroyedSignaled
+- VkLayerTest.RenderPassIncompatible
+
+### Skipped Tests
+
+- VkLayerTest.BindImageInvalidMemoryType
+- VkLayerTest.CreatePipelineBadVertexAttributeFormat
+- VkLayerTest.MiscBlitImageTests
+- VkLayerTest.TemporaryExternalSemaphore
+- VkLayerTest.TemporaryExternalFence
+- VkLayerTest.InvalidBarriers
+- VkLayerTest.CommandQueueFlags
+- VkPositiveLayerTest.TwoQueuesEnsureCorrectRetirementWithWorkStolen
+- VkPositiveLayerTest.ExternalSemaphore
+- VkPositiveLayerTest.ExternalFence
+- VkPositiveLayerTest.ExternalMemory
diff --git a/tools/Vulkan-Tools/icd/VkICD_mock_icd.def b/tools/Vulkan-Tools/icd/VkICD_mock_icd.def
new file mode 100644
index 00000000..490fb3e2
--- /dev/null
+++ b/tools/Vulkan-Tools/icd/VkICD_mock_icd.def
@@ -0,0 +1,36 @@
+
+;;;; Begin Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;
+; Copyright (c) 2015-2017 The Khronos Group Inc.
+; Copyright (c) 2015-2017 Valve Corporation
+; Copyright (c) 2015-2017 LunarG, Inc.
+; Copyright (c) 2015-2017 Google Inc.
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+;     http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS,
+; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+; See the License for the specific language governing permissions and
+; limitations under the License.
+;
+;  Author: Tobin Ehlis <tobine@google.com>
+;
+;;;;  End Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+LIBRARY VkICD_mock_icd
+EXPORTS
+vk_icdGetInstanceProcAddr
+vk_icdGetPhysicalDeviceProcAddr
+vk_icdNegotiateLoaderICDInterfaceVersion
+vkDestroySurfaceKHR
+vkGetPhysicalDeviceSurfaceSupportKHR
+vkGetPhysicalDeviceSurfaceCapabilitiesKHR
+vkGetPhysicalDeviceSurfaceFormatsKHR
+vkGetPhysicalDeviceSurfacePresentModesKHR
+vkCreateDisplayPlaneSurfaceKHR
+vkCreateWin32SurfaceKHR
diff --git a/tools/Vulkan-Tools/icd/VkICD_mock_icd.json.in b/tools/Vulkan-Tools/icd/VkICD_mock_icd.json.in
new file mode 100644
index 00000000..3522c472
--- /dev/null
+++ b/tools/Vulkan-Tools/icd/VkICD_mock_icd.json.in
@@ -0,0 +1,7 @@
+{
+    "file_format_version": "1.0.1",
+    "ICD": {
+        "library_path": "@JSON_LIBRARY_PATH@",
+        "api_version": "1.4.347"
+    }
+}
\ No newline at end of file
diff --git a/tools/Vulkan-Tools/icd/generated/.clang-format b/tools/Vulkan-Tools/icd/generated/.clang-format
new file mode 100644
index 00000000..3bb983a4
--- /dev/null
+++ b/tools/Vulkan-Tools/icd/generated/.clang-format
@@ -0,0 +1,5 @@
+---
+# Disable clang-format for generated code
+DisableFormat: true
+SortIncludes: false
+...
diff --git a/tools/Vulkan-Tools/icd/generated/function_declarations.h b/tools/Vulkan-Tools/icd/generated/function_declarations.h
new file mode 100644
index 00000000..f50e075f
--- /dev/null
+++ b/tools/Vulkan-Tools/icd/generated/function_declarations.h
@@ -0,0 +1,4132 @@
+/*
+** Copyright (c) 2015-2025 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+#pragma once
+#include <stdint.h>
+#include <cstring>
+#include <string>
+#include <unordered_map>
+#include <vulkan/vulkan.h>
+
+namespace vkmock {
+// Map of instance extension name to version
+static const std::unordered_map<std::string, uint32_t> instance_extension_map = {
+    {"VK_KHR_surface", VK_KHR_SURFACE_SPEC_VERSION},
+    {"VK_KHR_display", VK_KHR_DISPLAY_SPEC_VERSION},
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+    {"VK_KHR_xlib_surface", VK_KHR_XLIB_SURFACE_SPEC_VERSION},
+#endif
+#ifdef VK_USE_PLATFORM_XCB_KHR
+    {"VK_KHR_xcb_surface", VK_KHR_XCB_SURFACE_SPEC_VERSION},
+#endif
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+    {"VK_KHR_wayland_surface", VK_KHR_WAYLAND_SURFACE_SPEC_VERSION},
+#endif
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+    {"VK_KHR_android_surface", VK_KHR_ANDROID_SURFACE_SPEC_VERSION},
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    {"VK_KHR_win32_surface", VK_KHR_WIN32_SURFACE_SPEC_VERSION},
+#endif
+    {"VK_KHR_get_physical_device_properties2", VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION},
+    {"VK_KHR_device_group_creation", VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION},
+    {"VK_KHR_external_memory_capabilities", VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION},
+    {"VK_KHR_external_semaphore_capabilities", VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION},
+    {"VK_KHR_external_fence_capabilities", VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION},
+    {"VK_KHR_get_surface_capabilities2", VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION},
+    {"VK_KHR_get_display_properties2", VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION},
+    {"VK_KHR_surface_protected_capabilities", VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION},
+    {"VK_KHR_portability_enumeration", VK_KHR_PORTABILITY_ENUMERATION_SPEC_VERSION},
+    {"VK_KHR_surface_maintenance1", VK_KHR_SURFACE_MAINTENANCE_1_SPEC_VERSION},
+    {"VK_EXT_debug_report", VK_EXT_DEBUG_REPORT_SPEC_VERSION},
+#ifdef VK_USE_PLATFORM_GGP
+    {"VK_GGP_stream_descriptor_surface", VK_GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION},
+#endif
+    {"VK_NV_external_memory_capabilities", VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION},
+    {"VK_EXT_validation_flags", VK_EXT_VALIDATION_FLAGS_SPEC_VERSION},
+#ifdef VK_USE_PLATFORM_VI_NN
+    {"VK_NN_vi_surface", VK_NN_VI_SURFACE_SPEC_VERSION},
+#endif
+    {"VK_EXT_direct_mode_display", VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION},
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+    {"VK_EXT_acquire_xlib_display", VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION},
+#endif
+    {"VK_EXT_display_surface_counter", VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION},
+    {"VK_EXT_swapchain_colorspace", VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION},
+#ifdef VK_USE_PLATFORM_IOS_MVK
+    {"VK_MVK_ios_surface", VK_MVK_IOS_SURFACE_SPEC_VERSION},
+#endif
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+    {"VK_MVK_macos_surface", VK_MVK_MACOS_SURFACE_SPEC_VERSION},
+#endif
+    {"VK_EXT_debug_utils", VK_EXT_DEBUG_UTILS_SPEC_VERSION},
+#ifdef VK_USE_PLATFORM_FUCHSIA
+    {"VK_FUCHSIA_imagepipe_surface", VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION},
+#endif
+#ifdef VK_USE_PLATFORM_METAL_EXT
+    {"VK_EXT_metal_surface", VK_EXT_METAL_SURFACE_SPEC_VERSION},
+#endif
+    {"VK_EXT_validation_features", VK_EXT_VALIDATION_FEATURES_SPEC_VERSION},
+    {"VK_EXT_headless_surface", VK_EXT_HEADLESS_SURFACE_SPEC_VERSION},
+    {"VK_EXT_surface_maintenance1", VK_EXT_SURFACE_MAINTENANCE_1_SPEC_VERSION},
+    {"VK_EXT_acquire_drm_display", VK_EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION},
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+    {"VK_EXT_directfb_surface", VK_EXT_DIRECTFB_SURFACE_SPEC_VERSION},
+#endif
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+    {"VK_QNX_screen_surface", VK_QNX_SCREEN_SURFACE_SPEC_VERSION},
+#endif
+    {"VK_GOOGLE_surfaceless_query", VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION},
+    {"VK_LUNARG_direct_driver_loading", VK_LUNARG_DIRECT_DRIVER_LOADING_SPEC_VERSION},
+    {"VK_EXT_layer_settings", VK_EXT_LAYER_SETTINGS_SPEC_VERSION},
+    {"VK_NV_display_stereo", VK_NV_DISPLAY_STEREO_SPEC_VERSION},
+#ifdef VK_USE_PLATFORM_OHOS
+    {"VK_OHOS_surface", VK_OHOS_SURFACE_SPEC_VERSION},
+#endif
+#ifdef VK_USE_PLATFORM_UBM_SEC
+    {"VK_SEC_ubm_surface", VK_SEC_UBM_SURFACE_SPEC_VERSION},
+#endif
+};
+// Map of device extension name to version
+static const std::unordered_map<std::string, uint32_t> device_extension_map = {
+    {"VK_KHR_swapchain", VK_KHR_SWAPCHAIN_SPEC_VERSION},
+    {"VK_KHR_display_swapchain", VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION},
+    {"VK_KHR_sampler_mirror_clamp_to_edge", VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION},
+    {"VK_KHR_video_queue", VK_KHR_VIDEO_QUEUE_SPEC_VERSION},
+    {"VK_KHR_video_decode_queue", VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION},
+    {"VK_KHR_video_encode_h264", VK_KHR_VIDEO_ENCODE_H264_SPEC_VERSION},
+    {"VK_KHR_video_encode_h265", VK_KHR_VIDEO_ENCODE_H265_SPEC_VERSION},
+    {"VK_KHR_video_decode_h264", VK_KHR_VIDEO_DECODE_H264_SPEC_VERSION},
+    {"VK_KHR_dynamic_rendering", VK_KHR_DYNAMIC_RENDERING_SPEC_VERSION},
+    {"VK_KHR_multiview", VK_KHR_MULTIVIEW_SPEC_VERSION},
+    {"VK_KHR_device_group", VK_KHR_DEVICE_GROUP_SPEC_VERSION},
+    {"VK_KHR_shader_draw_parameters", VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION},
+    {"VK_KHR_maintenance1", VK_KHR_MAINTENANCE_1_SPEC_VERSION},
+    {"VK_KHR_external_memory", VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    {"VK_KHR_external_memory_win32", VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION},
+#endif
+    {"VK_KHR_external_memory_fd", VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    {"VK_KHR_win32_keyed_mutex", VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION},
+#endif
+    {"VK_KHR_external_semaphore", VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    {"VK_KHR_external_semaphore_win32", VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION},
+#endif
+    {"VK_KHR_external_semaphore_fd", VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION},
+    {"VK_KHR_push_descriptor", VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION},
+    {"VK_KHR_shader_float16_int8", VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION},
+    {"VK_KHR_16bit_storage", VK_KHR_16BIT_STORAGE_SPEC_VERSION},
+    {"VK_KHR_incremental_present", VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION},
+    {"VK_KHR_descriptor_update_template", VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION},
+    {"VK_KHR_imageless_framebuffer", VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION},
+    {"VK_KHR_create_renderpass2", VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION},
+    {"VK_KHR_shared_presentable_image", VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION},
+    {"VK_KHR_external_fence", VK_KHR_EXTERNAL_FENCE_SPEC_VERSION},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    {"VK_KHR_external_fence_win32", VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION},
+#endif
+    {"VK_KHR_external_fence_fd", VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION},
+    {"VK_KHR_performance_query", VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION},
+    {"VK_KHR_maintenance2", VK_KHR_MAINTENANCE_2_SPEC_VERSION},
+    {"VK_KHR_variable_pointers", VK_KHR_VARIABLE_POINTERS_SPEC_VERSION},
+    {"VK_KHR_dedicated_allocation", VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION},
+    {"VK_KHR_storage_buffer_storage_class", VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION},
+    {"VK_KHR_shader_bfloat16", VK_KHR_SHADER_BFLOAT16_SPEC_VERSION},
+    {"VK_KHR_relaxed_block_layout", VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION},
+    {"VK_KHR_get_memory_requirements2", VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION},
+    {"VK_KHR_image_format_list", VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION},
+    {"VK_KHR_sampler_ycbcr_conversion", VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION},
+    {"VK_KHR_bind_memory2", VK_KHR_BIND_MEMORY_2_SPEC_VERSION},
+    {"VK_KHR_maintenance3", VK_KHR_MAINTENANCE_3_SPEC_VERSION},
+    {"VK_KHR_draw_indirect_count", VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION},
+    {"VK_KHR_shader_subgroup_extended_types", VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION},
+    {"VK_KHR_8bit_storage", VK_KHR_8BIT_STORAGE_SPEC_VERSION},
+    {"VK_KHR_shader_atomic_int64", VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION},
+    {"VK_KHR_shader_clock", VK_KHR_SHADER_CLOCK_SPEC_VERSION},
+    {"VK_KHR_video_decode_h265", VK_KHR_VIDEO_DECODE_H265_SPEC_VERSION},
+    {"VK_KHR_global_priority", VK_KHR_GLOBAL_PRIORITY_SPEC_VERSION},
+    {"VK_KHR_driver_properties", VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION},
+    {"VK_KHR_shader_float_controls", VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION},
+    {"VK_KHR_depth_stencil_resolve", VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION},
+    {"VK_KHR_swapchain_mutable_format", VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION},
+    {"VK_KHR_timeline_semaphore", VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION},
+    {"VK_KHR_vulkan_memory_model", VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION},
+    {"VK_KHR_shader_terminate_invocation", VK_KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION},
+    {"VK_KHR_fragment_shading_rate", VK_KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION},
+    {"VK_KHR_shader_constant_data", VK_KHR_SHADER_CONSTANT_DATA_SPEC_VERSION},
+    {"VK_KHR_dynamic_rendering_local_read", VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION},
+    {"VK_KHR_shader_abort", VK_KHR_SHADER_ABORT_SPEC_VERSION},
+    {"VK_KHR_shader_quad_control", VK_KHR_SHADER_QUAD_CONTROL_SPEC_VERSION},
+    {"VK_KHR_spirv_1_4", VK_KHR_SPIRV_1_4_SPEC_VERSION},
+    {"VK_KHR_separate_depth_stencil_layouts", VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION},
+    {"VK_KHR_present_wait", VK_KHR_PRESENT_WAIT_SPEC_VERSION},
+    {"VK_KHR_uniform_buffer_standard_layout", VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION},
+    {"VK_KHR_buffer_device_address", VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION},
+    {"VK_KHR_deferred_host_operations", VK_KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION},
+    {"VK_KHR_pipeline_executable_properties", VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION},
+    {"VK_KHR_map_memory2", VK_KHR_MAP_MEMORY_2_SPEC_VERSION},
+    {"VK_KHR_shader_integer_dot_product", VK_KHR_SHADER_INTEGER_DOT_PRODUCT_SPEC_VERSION},
+    {"VK_KHR_pipeline_library", VK_KHR_PIPELINE_LIBRARY_SPEC_VERSION},
+    {"VK_KHR_shader_non_semantic_info", VK_KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION},
+    {"VK_KHR_present_id", VK_KHR_PRESENT_ID_SPEC_VERSION},
+    {"VK_KHR_video_encode_queue", VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION},
+    {"VK_KHR_synchronization2", VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION},
+    {"VK_KHR_device_address_commands", VK_KHR_DEVICE_ADDRESS_COMMANDS_SPEC_VERSION},
+    {"VK_KHR_fragment_shader_barycentric", VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION},
+    {"VK_KHR_shader_subgroup_uniform_control_flow", VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION},
+    {"VK_KHR_zero_initialize_workgroup_memory", VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION},
+    {"VK_KHR_workgroup_memory_explicit_layout", VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION},
+    {"VK_KHR_copy_commands2", VK_KHR_COPY_COMMANDS_2_SPEC_VERSION},
+    {"VK_KHR_format_feature_flags2", VK_KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION},
+    {"VK_KHR_ray_tracing_maintenance1", VK_KHR_RAY_TRACING_MAINTENANCE_1_SPEC_VERSION},
+    {"VK_KHR_shader_untyped_pointers", VK_KHR_SHADER_UNTYPED_POINTERS_SPEC_VERSION},
+    {"VK_KHR_maintenance4", VK_KHR_MAINTENANCE_4_SPEC_VERSION},
+    {"VK_KHR_shader_subgroup_rotate", VK_KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION},
+    {"VK_KHR_shader_maximal_reconvergence", VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_SPEC_VERSION},
+    {"VK_KHR_maintenance5", VK_KHR_MAINTENANCE_5_SPEC_VERSION},
+    {"VK_KHR_present_id2", VK_KHR_PRESENT_ID_2_SPEC_VERSION},
+    {"VK_KHR_present_wait2", VK_KHR_PRESENT_WAIT_2_SPEC_VERSION},
+    {"VK_KHR_ray_tracing_position_fetch", VK_KHR_RAY_TRACING_POSITION_FETCH_SPEC_VERSION},
+    {"VK_KHR_pipeline_binary", VK_KHR_PIPELINE_BINARY_SPEC_VERSION},
+    {"VK_KHR_swapchain_maintenance1", VK_KHR_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION},
+    {"VK_KHR_internally_synchronized_queues", VK_KHR_INTERNALLY_SYNCHRONIZED_QUEUES_SPEC_VERSION},
+    {"VK_KHR_cooperative_matrix", VK_KHR_COOPERATIVE_MATRIX_SPEC_VERSION},
+    {"VK_KHR_compute_shader_derivatives", VK_KHR_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION},
+    {"VK_KHR_video_decode_av1", VK_KHR_VIDEO_DECODE_AV1_SPEC_VERSION},
+    {"VK_KHR_video_encode_av1", VK_KHR_VIDEO_ENCODE_AV1_SPEC_VERSION},
+    {"VK_KHR_video_decode_vp9", VK_KHR_VIDEO_DECODE_VP9_SPEC_VERSION},
+    {"VK_KHR_video_maintenance1", VK_KHR_VIDEO_MAINTENANCE_1_SPEC_VERSION},
+    {"VK_KHR_vertex_attribute_divisor", VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION},
+    {"VK_KHR_load_store_op_none", VK_KHR_LOAD_STORE_OP_NONE_SPEC_VERSION},
+    {"VK_KHR_unified_image_layouts", VK_KHR_UNIFIED_IMAGE_LAYOUTS_SPEC_VERSION},
+    {"VK_KHR_shader_float_controls2", VK_KHR_SHADER_FLOAT_CONTROLS_2_SPEC_VERSION},
+    {"VK_KHR_index_type_uint8", VK_KHR_INDEX_TYPE_UINT8_SPEC_VERSION},
+    {"VK_KHR_line_rasterization", VK_KHR_LINE_RASTERIZATION_SPEC_VERSION},
+    {"VK_KHR_calibrated_timestamps", VK_KHR_CALIBRATED_TIMESTAMPS_SPEC_VERSION},
+    {"VK_KHR_shader_expect_assume", VK_KHR_SHADER_EXPECT_ASSUME_SPEC_VERSION},
+    {"VK_KHR_maintenance6", VK_KHR_MAINTENANCE_6_SPEC_VERSION},
+    {"VK_KHR_copy_memory_indirect", VK_KHR_COPY_MEMORY_INDIRECT_SPEC_VERSION},
+    {"VK_KHR_video_encode_intra_refresh", VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_SPEC_VERSION},
+    {"VK_KHR_video_encode_quantization_map", VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_SPEC_VERSION},
+    {"VK_KHR_shader_relaxed_extended_instruction", VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_SPEC_VERSION},
+    {"VK_KHR_maintenance7", VK_KHR_MAINTENANCE_7_SPEC_VERSION},
+    {"VK_KHR_device_fault", VK_KHR_DEVICE_FAULT_SPEC_VERSION},
+    {"VK_KHR_maintenance8", VK_KHR_MAINTENANCE_8_SPEC_VERSION},
+    {"VK_KHR_shader_fma", VK_KHR_SHADER_FMA_SPEC_VERSION},
+    {"VK_KHR_maintenance9", VK_KHR_MAINTENANCE_9_SPEC_VERSION},
+    {"VK_KHR_video_maintenance2", VK_KHR_VIDEO_MAINTENANCE_2_SPEC_VERSION},
+    {"VK_KHR_depth_clamp_zero_one", VK_KHR_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION},
+    {"VK_KHR_robustness2", VK_KHR_ROBUSTNESS_2_SPEC_VERSION},
+    {"VK_KHR_present_mode_fifo_latest_ready", VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION},
+    {"VK_KHR_maintenance10", VK_KHR_MAINTENANCE_10_SPEC_VERSION},
+    {"VK_NV_glsl_shader", VK_NV_GLSL_SHADER_SPEC_VERSION},
+    {"VK_EXT_depth_range_unrestricted", VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION},
+    {"VK_IMG_filter_cubic", VK_IMG_FILTER_CUBIC_SPEC_VERSION},
+    {"VK_AMD_rasterization_order", VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION},
+    {"VK_AMD_shader_trinary_minmax", VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION},
+    {"VK_AMD_shader_explicit_vertex_parameter", VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION},
+    {"VK_EXT_debug_marker", VK_EXT_DEBUG_MARKER_SPEC_VERSION},
+    {"VK_AMD_gcn_shader", VK_AMD_GCN_SHADER_SPEC_VERSION},
+    {"VK_NV_dedicated_allocation", VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION},
+    {"VK_EXT_transform_feedback", VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION},
+    {"VK_NVX_binary_import", VK_NVX_BINARY_IMPORT_SPEC_VERSION},
+    {"VK_NVX_image_view_handle", VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION},
+    {"VK_AMD_draw_indirect_count", VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION},
+    {"VK_AMD_negative_viewport_height", VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION},
+    {"VK_AMD_gpu_shader_half_float", VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION},
+    {"VK_AMD_shader_ballot", VK_AMD_SHADER_BALLOT_SPEC_VERSION},
+    {"VK_AMD_texture_gather_bias_lod", VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION},
+    {"VK_AMD_shader_info", VK_AMD_SHADER_INFO_SPEC_VERSION},
+    {"VK_AMD_shader_image_load_store_lod", VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION},
+    {"VK_NV_corner_sampled_image", VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION},
+    {"VK_IMG_format_pvrtc", VK_IMG_FORMAT_PVRTC_SPEC_VERSION},
+    {"VK_NV_external_memory", VK_NV_EXTERNAL_MEMORY_SPEC_VERSION},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    {"VK_NV_external_memory_win32", VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION},
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    {"VK_NV_win32_keyed_mutex", VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION},
+#endif
+    {"VK_EXT_shader_subgroup_ballot", VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION},
+    {"VK_EXT_shader_subgroup_vote", VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION},
+    {"VK_EXT_texture_compression_astc_hdr", VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION},
+    {"VK_EXT_astc_decode_mode", VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION},
+    {"VK_EXT_pipeline_robustness", VK_EXT_PIPELINE_ROBUSTNESS_SPEC_VERSION},
+    {"VK_EXT_conditional_rendering", VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION},
+    {"VK_NV_clip_space_w_scaling", VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION},
+    {"VK_EXT_display_control", VK_EXT_DISPLAY_CONTROL_SPEC_VERSION},
+    {"VK_GOOGLE_display_timing", VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION},
+    {"VK_NV_sample_mask_override_coverage", VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION},
+    {"VK_NV_geometry_shader_passthrough", VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION},
+    {"VK_NV_viewport_array2", VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION},
+    {"VK_NVX_multiview_per_view_attributes", VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION},
+    {"VK_NV_viewport_swizzle", VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION},
+    {"VK_EXT_discard_rectangles", VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION},
+    {"VK_EXT_conservative_rasterization", VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION},
+    {"VK_EXT_depth_clip_enable", VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION},
+    {"VK_EXT_hdr_metadata", VK_EXT_HDR_METADATA_SPEC_VERSION},
+    {"VK_IMG_relaxed_line_rasterization", VK_IMG_RELAXED_LINE_RASTERIZATION_SPEC_VERSION},
+    {"VK_EXT_external_memory_dma_buf", VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION},
+    {"VK_EXT_queue_family_foreign", VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION},
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+    {"VK_ANDROID_external_memory_android_hardware_buffer", VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION},
+#endif
+    {"VK_EXT_sampler_filter_minmax", VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION},
+    {"VK_AMD_gpu_shader_int16", VK_AMD_GPU_SHADER_INT16_SPEC_VERSION},
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    {"VK_AMDX_shader_enqueue", VK_AMDX_SHADER_ENQUEUE_SPEC_VERSION},
+#endif
+    {"VK_EXT_descriptor_heap", VK_EXT_DESCRIPTOR_HEAP_SPEC_VERSION},
+    {"VK_AMD_mixed_attachment_samples", VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION},
+    {"VK_AMD_shader_fragment_mask", VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION},
+    {"VK_EXT_inline_uniform_block", VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION},
+    {"VK_EXT_shader_stencil_export", VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION},
+    {"VK_EXT_sample_locations", VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION},
+    {"VK_EXT_blend_operation_advanced", VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION},
+    {"VK_NV_fragment_coverage_to_color", VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION},
+    {"VK_NV_framebuffer_mixed_samples", VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION},
+    {"VK_NV_fill_rectangle", VK_NV_FILL_RECTANGLE_SPEC_VERSION},
+    {"VK_NV_shader_sm_builtins", VK_NV_SHADER_SM_BUILTINS_SPEC_VERSION},
+    {"VK_EXT_post_depth_coverage", VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION},
+    {"VK_EXT_image_drm_format_modifier", VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION},
+    {"VK_EXT_descriptor_indexing", VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION},
+    {"VK_EXT_shader_viewport_index_layer", VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION},
+    {"VK_NV_shading_rate_image", VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION},
+    {"VK_NV_ray_tracing", VK_NV_RAY_TRACING_SPEC_VERSION},
+    {"VK_NV_representative_fragment_test", VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION},
+    {"VK_EXT_filter_cubic", VK_EXT_FILTER_CUBIC_SPEC_VERSION},
+    {"VK_QCOM_render_pass_shader_resolve", VK_QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION},
+    {"VK_QCOM_cooperative_matrix_conversion", VK_QCOM_COOPERATIVE_MATRIX_CONVERSION_SPEC_VERSION},
+    {"VK_EXT_global_priority", VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION},
+    {"VK_EXT_external_memory_host", VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION},
+    {"VK_AMD_buffer_marker", VK_AMD_BUFFER_MARKER_SPEC_VERSION},
+    {"VK_AMD_pipeline_compiler_control", VK_AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION},
+    {"VK_EXT_calibrated_timestamps", VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION},
+    {"VK_AMD_shader_core_properties", VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION},
+    {"VK_AMD_memory_overallocation_behavior", VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION},
+    {"VK_EXT_vertex_attribute_divisor", VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION},
+#ifdef VK_USE_PLATFORM_GGP
+    {"VK_GGP_frame_token", VK_GGP_FRAME_TOKEN_SPEC_VERSION},
+#endif
+    {"VK_EXT_pipeline_creation_feedback", VK_EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION},
+    {"VK_NV_shader_subgroup_partitioned", VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION},
+    {"VK_NV_compute_shader_derivatives", VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION},
+    {"VK_NV_mesh_shader", VK_NV_MESH_SHADER_SPEC_VERSION},
+    {"VK_NV_fragment_shader_barycentric", VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION},
+    {"VK_NV_shader_image_footprint", VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION},
+    {"VK_NV_scissor_exclusive", VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION},
+    {"VK_NV_device_diagnostic_checkpoints", VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION},
+    {"VK_EXT_present_timing", VK_EXT_PRESENT_TIMING_SPEC_VERSION},
+    {"VK_INTEL_shader_integer_functions2", VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION},
+    {"VK_INTEL_performance_query", VK_INTEL_PERFORMANCE_QUERY_SPEC_VERSION},
+    {"VK_EXT_pci_bus_info", VK_EXT_PCI_BUS_INFO_SPEC_VERSION},
+    {"VK_AMD_display_native_hdr", VK_AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION},
+    {"VK_EXT_fragment_density_map", VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION},
+    {"VK_EXT_scalar_block_layout", VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION},
+    {"VK_GOOGLE_hlsl_functionality1", VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION},
+    {"VK_GOOGLE_decorate_string", VK_GOOGLE_DECORATE_STRING_SPEC_VERSION},
+    {"VK_EXT_subgroup_size_control", VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION},
+    {"VK_AMD_shader_core_properties2", VK_AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION},
+    {"VK_AMD_device_coherent_memory", VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION},
+    {"VK_EXT_shader_image_atomic_int64", VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION},
+    {"VK_EXT_memory_budget", VK_EXT_MEMORY_BUDGET_SPEC_VERSION},
+    {"VK_EXT_memory_priority", VK_EXT_MEMORY_PRIORITY_SPEC_VERSION},
+    {"VK_NV_dedicated_allocation_image_aliasing", VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION},
+    {"VK_EXT_buffer_device_address", VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION},
+    {"VK_EXT_tooling_info", VK_EXT_TOOLING_INFO_SPEC_VERSION},
+    {"VK_EXT_separate_stencil_usage", VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION},
+    {"VK_NV_cooperative_matrix", VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION},
+    {"VK_NV_coverage_reduction_mode", VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION},
+    {"VK_EXT_fragment_shader_interlock", VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION},
+    {"VK_EXT_ycbcr_image_arrays", VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION},
+    {"VK_EXT_provoking_vertex", VK_EXT_PROVOKING_VERTEX_SPEC_VERSION},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    {"VK_EXT_full_screen_exclusive", VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION},
+#endif
+    {"VK_EXT_line_rasterization", VK_EXT_LINE_RASTERIZATION_SPEC_VERSION},
+    {"VK_EXT_shader_atomic_float", VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION},
+    {"VK_EXT_host_query_reset", VK_EXT_HOST_QUERY_RESET_SPEC_VERSION},
+    {"VK_EXT_index_type_uint8", VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION},
+    {"VK_EXT_extended_dynamic_state", VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION},
+    {"VK_EXT_host_image_copy", VK_EXT_HOST_IMAGE_COPY_SPEC_VERSION},
+    {"VK_EXT_map_memory_placed", VK_EXT_MAP_MEMORY_PLACED_SPEC_VERSION},
+    {"VK_EXT_shader_atomic_float2", VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION},
+    {"VK_EXT_swapchain_maintenance1", VK_EXT_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION},
+    {"VK_EXT_shader_demote_to_helper_invocation", VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION},
+    {"VK_NV_device_generated_commands", VK_NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION},
+    {"VK_NV_inherited_viewport_scissor", VK_NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION},
+    {"VK_EXT_texel_buffer_alignment", VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION},
+    {"VK_QCOM_render_pass_transform", VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION},
+    {"VK_EXT_depth_bias_control", VK_EXT_DEPTH_BIAS_CONTROL_SPEC_VERSION},
+    {"VK_EXT_device_memory_report", VK_EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION},
+    {"VK_EXT_robustness2", VK_EXT_ROBUSTNESS_2_SPEC_VERSION},
+    {"VK_EXT_custom_border_color", VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION},
+    {"VK_EXT_texture_compression_astc_3d", VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_SPEC_VERSION},
+    {"VK_GOOGLE_user_type", VK_GOOGLE_USER_TYPE_SPEC_VERSION},
+    {"VK_NV_present_barrier", VK_NV_PRESENT_BARRIER_SPEC_VERSION},
+    {"VK_EXT_private_data", VK_EXT_PRIVATE_DATA_SPEC_VERSION},
+    {"VK_EXT_pipeline_creation_cache_control", VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION},
+    {"VK_NV_device_diagnostics_config", VK_NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION},
+    {"VK_QCOM_render_pass_store_ops", VK_QCOM_RENDER_PASS_STORE_OPS_SPEC_VERSION},
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    {"VK_NV_cuda_kernel_launch", VK_NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION},
+#endif
+    {"VK_QCOM_tile_shading", VK_QCOM_TILE_SHADING_SPEC_VERSION},
+    {"VK_NV_low_latency", VK_NV_LOW_LATENCY_SPEC_VERSION},
+#ifdef VK_USE_PLATFORM_METAL_EXT
+    {"VK_EXT_metal_objects", VK_EXT_METAL_OBJECTS_SPEC_VERSION},
+#endif
+    {"VK_EXT_descriptor_buffer", VK_EXT_DESCRIPTOR_BUFFER_SPEC_VERSION},
+    {"VK_EXT_graphics_pipeline_library", VK_EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION},
+    {"VK_AMD_shader_early_and_late_fragment_tests", VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_SPEC_VERSION},
+    {"VK_NV_fragment_shading_rate_enums", VK_NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION},
+    {"VK_NV_ray_tracing_motion_blur", VK_NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION},
+    {"VK_EXT_ycbcr_2plane_444_formats", VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION},
+    {"VK_EXT_fragment_density_map2", VK_EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION},
+    {"VK_QCOM_rotated_copy_commands", VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION},
+    {"VK_EXT_image_robustness", VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION},
+    {"VK_EXT_image_compression_control", VK_EXT_IMAGE_COMPRESSION_CONTROL_SPEC_VERSION},
+    {"VK_EXT_attachment_feedback_loop_layout", VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_SPEC_VERSION},
+    {"VK_EXT_4444_formats", VK_EXT_4444_FORMATS_SPEC_VERSION},
+    {"VK_EXT_device_fault", VK_EXT_DEVICE_FAULT_SPEC_VERSION},
+    {"VK_ARM_rasterization_order_attachment_access", VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION},
+    {"VK_EXT_rgba10x6_formats", VK_EXT_RGBA10X6_FORMATS_SPEC_VERSION},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    {"VK_NV_acquire_winrt_display", VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION},
+#endif
+    {"VK_VALVE_mutable_descriptor_type", VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION},
+    {"VK_EXT_vertex_input_dynamic_state", VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION},
+    {"VK_EXT_physical_device_drm", VK_EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION},
+    {"VK_EXT_device_address_binding_report", VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_SPEC_VERSION},
+    {"VK_EXT_depth_clip_control", VK_EXT_DEPTH_CLIP_CONTROL_SPEC_VERSION},
+    {"VK_EXT_primitive_topology_list_restart", VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_SPEC_VERSION},
+    {"VK_EXT_present_mode_fifo_latest_ready", VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION},
+#ifdef VK_USE_PLATFORM_FUCHSIA
+    {"VK_FUCHSIA_external_memory", VK_FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION},
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+    {"VK_FUCHSIA_external_semaphore", VK_FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION},
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+    {"VK_FUCHSIA_buffer_collection", VK_FUCHSIA_BUFFER_COLLECTION_SPEC_VERSION},
+#endif
+    {"VK_HUAWEI_subpass_shading", VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION},
+    {"VK_HUAWEI_invocation_mask", VK_HUAWEI_INVOCATION_MASK_SPEC_VERSION},
+    {"VK_NV_external_memory_rdma", VK_NV_EXTERNAL_MEMORY_RDMA_SPEC_VERSION},
+    {"VK_EXT_pipeline_properties", VK_EXT_PIPELINE_PROPERTIES_SPEC_VERSION},
+    {"VK_EXT_frame_boundary", VK_EXT_FRAME_BOUNDARY_SPEC_VERSION},
+    {"VK_EXT_multisampled_render_to_single_sampled", VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_SPEC_VERSION},
+    {"VK_EXT_extended_dynamic_state2", VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION},
+    {"VK_EXT_color_write_enable", VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION},
+    {"VK_EXT_primitives_generated_query", VK_EXT_PRIMITIVES_GENERATED_QUERY_SPEC_VERSION},
+    {"VK_EXT_global_priority_query", VK_EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION},
+    {"VK_VALVE_video_encode_rgb_conversion", VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_SPEC_VERSION},
+    {"VK_EXT_image_view_min_lod", VK_EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION},
+    {"VK_EXT_multi_draw", VK_EXT_MULTI_DRAW_SPEC_VERSION},
+    {"VK_EXT_image_2d_view_of_3d", VK_EXT_IMAGE_2D_VIEW_OF_3D_SPEC_VERSION},
+    {"VK_EXT_shader_tile_image", VK_EXT_SHADER_TILE_IMAGE_SPEC_VERSION},
+    {"VK_EXT_opacity_micromap", VK_EXT_OPACITY_MICROMAP_SPEC_VERSION},
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    {"VK_NV_displacement_micromap", VK_NV_DISPLACEMENT_MICROMAP_SPEC_VERSION},
+#endif
+    {"VK_EXT_load_store_op_none", VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION},
+    {"VK_HUAWEI_cluster_culling_shader", VK_HUAWEI_CLUSTER_CULLING_SHADER_SPEC_VERSION},
+    {"VK_EXT_border_color_swizzle", VK_EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION},
+    {"VK_EXT_pageable_device_local_memory", VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_SPEC_VERSION},
+    {"VK_ARM_shader_core_properties", VK_ARM_SHADER_CORE_PROPERTIES_SPEC_VERSION},
+    {"VK_ARM_scheduling_controls", VK_ARM_SCHEDULING_CONTROLS_SPEC_VERSION},
+    {"VK_EXT_image_sliced_view_of_3d", VK_EXT_IMAGE_SLICED_VIEW_OF_3D_SPEC_VERSION},
+    {"VK_VALVE_descriptor_set_host_mapping", VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_SPEC_VERSION},
+    {"VK_EXT_depth_clamp_zero_one", VK_EXT_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION},
+    {"VK_EXT_non_seamless_cube_map", VK_EXT_NON_SEAMLESS_CUBE_MAP_SPEC_VERSION},
+    {"VK_ARM_render_pass_striped", VK_ARM_RENDER_PASS_STRIPED_SPEC_VERSION},
+    {"VK_QCOM_fragment_density_map_offset", VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION},
+    {"VK_NV_copy_memory_indirect", VK_NV_COPY_MEMORY_INDIRECT_SPEC_VERSION},
+    {"VK_NV_memory_decompression", VK_NV_MEMORY_DECOMPRESSION_SPEC_VERSION},
+    {"VK_NV_device_generated_commands_compute", VK_NV_DEVICE_GENERATED_COMMANDS_COMPUTE_SPEC_VERSION},
+    {"VK_NV_ray_tracing_linear_swept_spheres", VK_NV_RAY_TRACING_LINEAR_SWEPT_SPHERES_SPEC_VERSION},
+    {"VK_NV_linear_color_attachment", VK_NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION},
+    {"VK_EXT_image_compression_control_swapchain", VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_SPEC_VERSION},
+    {"VK_QCOM_image_processing", VK_QCOM_IMAGE_PROCESSING_SPEC_VERSION},
+    {"VK_EXT_nested_command_buffer", VK_EXT_NESTED_COMMAND_BUFFER_SPEC_VERSION},
+#ifdef VK_USE_PLATFORM_OHOS
+    {"VK_OHOS_external_memory", VK_OHOS_EXTERNAL_MEMORY_SPEC_VERSION},
+#endif
+    {"VK_EXT_external_memory_acquire_unmodified", VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_SPEC_VERSION},
+    {"VK_EXT_extended_dynamic_state3", VK_EXT_EXTENDED_DYNAMIC_STATE_3_SPEC_VERSION},
+    {"VK_EXT_subpass_merge_feedback", VK_EXT_SUBPASS_MERGE_FEEDBACK_SPEC_VERSION},
+    {"VK_ARM_tensors", VK_ARM_TENSORS_SPEC_VERSION},
+    {"VK_EXT_shader_module_identifier", VK_EXT_SHADER_MODULE_IDENTIFIER_SPEC_VERSION},
+    {"VK_EXT_rasterization_order_attachment_access", VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION},
+    {"VK_NV_optical_flow", VK_NV_OPTICAL_FLOW_SPEC_VERSION},
+    {"VK_EXT_legacy_dithering", VK_EXT_LEGACY_DITHERING_SPEC_VERSION},
+    {"VK_EXT_pipeline_protected_access", VK_EXT_PIPELINE_PROTECTED_ACCESS_SPEC_VERSION},
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+    {"VK_ANDROID_external_format_resolve", VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_SPEC_VERSION},
+#endif
+    {"VK_AMD_anti_lag", VK_AMD_ANTI_LAG_SPEC_VERSION},
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    {"VK_AMDX_dense_geometry_format", VK_AMDX_DENSE_GEOMETRY_FORMAT_SPEC_VERSION},
+#endif
+    {"VK_EXT_shader_object", VK_EXT_SHADER_OBJECT_SPEC_VERSION},
+    {"VK_QCOM_tile_properties", VK_QCOM_TILE_PROPERTIES_SPEC_VERSION},
+    {"VK_SEC_amigo_profiling", VK_SEC_AMIGO_PROFILING_SPEC_VERSION},
+    {"VK_QCOM_multiview_per_view_viewports", VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_SPEC_VERSION},
+    {"VK_NV_ray_tracing_invocation_reorder", VK_NV_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION},
+    {"VK_NV_cooperative_vector", VK_NV_COOPERATIVE_VECTOR_SPEC_VERSION},
+    {"VK_NV_extended_sparse_address_space", VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_SPEC_VERSION},
+    {"VK_EXT_mutable_descriptor_type", VK_EXT_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION},
+    {"VK_EXT_legacy_vertex_attributes", VK_EXT_LEGACY_VERTEX_ATTRIBUTES_SPEC_VERSION},
+    {"VK_ARM_shader_core_builtins", VK_ARM_SHADER_CORE_BUILTINS_SPEC_VERSION},
+    {"VK_EXT_pipeline_library_group_handles", VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_SPEC_VERSION},
+    {"VK_EXT_dynamic_rendering_unused_attachments", VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_SPEC_VERSION},
+    {"VK_NV_low_latency2", VK_NV_LOW_LATENCY_2_SPEC_VERSION},
+    {"VK_ARM_data_graph", VK_ARM_DATA_GRAPH_SPEC_VERSION},
+    {"VK_QCOM_multiview_per_view_render_areas", VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION},
+    {"VK_NV_per_stage_descriptor_set", VK_NV_PER_STAGE_DESCRIPTOR_SET_SPEC_VERSION},
+    {"VK_QCOM_image_processing2", VK_QCOM_IMAGE_PROCESSING_2_SPEC_VERSION},
+    {"VK_QCOM_filter_cubic_weights", VK_QCOM_FILTER_CUBIC_WEIGHTS_SPEC_VERSION},
+    {"VK_QCOM_ycbcr_degamma", VK_QCOM_YCBCR_DEGAMMA_SPEC_VERSION},
+    {"VK_QCOM_filter_cubic_clamp", VK_QCOM_FILTER_CUBIC_CLAMP_SPEC_VERSION},
+    {"VK_EXT_attachment_feedback_loop_dynamic_state", VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_SPEC_VERSION},
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+    {"VK_QNX_external_memory_screen_buffer", VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_SPEC_VERSION},
+#endif
+    {"VK_MSFT_layered_driver", VK_MSFT_LAYERED_DRIVER_SPEC_VERSION},
+    {"VK_NV_descriptor_pool_overallocation", VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_SPEC_VERSION},
+    {"VK_QCOM_tile_memory_heap", VK_QCOM_TILE_MEMORY_HEAP_SPEC_VERSION},
+    {"VK_EXT_memory_decompression", VK_EXT_MEMORY_DECOMPRESSION_SPEC_VERSION},
+    {"VK_NV_raw_access_chains", VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION},
+    {"VK_NV_external_compute_queue", VK_NV_EXTERNAL_COMPUTE_QUEUE_SPEC_VERSION},
+    {"VK_NV_command_buffer_inheritance", VK_NV_COMMAND_BUFFER_INHERITANCE_SPEC_VERSION},
+    {"VK_NV_shader_atomic_float16_vector", VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION},
+    {"VK_EXT_shader_replicated_composites", VK_EXT_SHADER_REPLICATED_COMPOSITES_SPEC_VERSION},
+    {"VK_EXT_shader_float8", VK_EXT_SHADER_FLOAT8_SPEC_VERSION},
+    {"VK_NV_ray_tracing_validation", VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION},
+    {"VK_NV_cluster_acceleration_structure", VK_NV_CLUSTER_ACCELERATION_STRUCTURE_SPEC_VERSION},
+    {"VK_NV_partitioned_acceleration_structure", VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_SPEC_VERSION},
+    {"VK_EXT_device_generated_commands", VK_EXT_DEVICE_GENERATED_COMMANDS_SPEC_VERSION},
+    {"VK_MESA_image_alignment_control", VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION},
+    {"VK_NV_push_constant_bank", VK_NV_PUSH_CONSTANT_BANK_SPEC_VERSION},
+    {"VK_EXT_ray_tracing_invocation_reorder", VK_EXT_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION},
+    {"VK_EXT_depth_clamp_control", VK_EXT_DEPTH_CLAMP_CONTROL_SPEC_VERSION},
+    {"VK_HUAWEI_hdr_vivid", VK_HUAWEI_HDR_VIVID_SPEC_VERSION},
+    {"VK_NV_cooperative_matrix2", VK_NV_COOPERATIVE_MATRIX_2_SPEC_VERSION},
+    {"VK_ARM_pipeline_opacity_micromap", VK_ARM_PIPELINE_OPACITY_MICROMAP_SPEC_VERSION},
+#ifdef VK_USE_PLATFORM_METAL_EXT
+    {"VK_EXT_external_memory_metal", VK_EXT_EXTERNAL_MEMORY_METAL_SPEC_VERSION},
+#endif
+    {"VK_ARM_performance_counters_by_region", VK_ARM_PERFORMANCE_COUNTERS_BY_REGION_SPEC_VERSION},
+    {"VK_ARM_shader_instrumentation", VK_ARM_SHADER_INSTRUMENTATION_SPEC_VERSION},
+    {"VK_EXT_vertex_attribute_robustness", VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_SPEC_VERSION},
+    {"VK_ARM_format_pack", VK_ARM_FORMAT_PACK_SPEC_VERSION},
+    {"VK_VALVE_fragment_density_map_layered", VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_SPEC_VERSION},
+    {"VK_NV_present_metering", VK_NV_PRESENT_METERING_SPEC_VERSION},
+    {"VK_EXT_fragment_density_map_offset", VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION},
+    {"VK_EXT_zero_initialize_device_memory", VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_SPEC_VERSION},
+    {"VK_EXT_shader_64bit_indexing", VK_EXT_SHADER_64BIT_INDEXING_SPEC_VERSION},
+    {"VK_EXT_custom_resolve", VK_EXT_CUSTOM_RESOLVE_SPEC_VERSION},
+    {"VK_QCOM_data_graph_model", VK_QCOM_DATA_GRAPH_MODEL_SPEC_VERSION},
+    {"VK_EXT_shader_long_vector", VK_EXT_SHADER_LONG_VECTOR_SPEC_VERSION},
+    {"VK_SEC_pipeline_cache_incremental_mode", VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_SPEC_VERSION},
+    {"VK_EXT_shader_uniform_buffer_unsized_array", VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_SPEC_VERSION},
+    {"VK_NV_compute_occupancy_priority", VK_NV_COMPUTE_OCCUPANCY_PRIORITY_SPEC_VERSION},
+    {"VK_EXT_shader_subgroup_partitioned", VK_EXT_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION},
+    {"VK_VALVE_shader_mixed_float_dot_product", VK_VALVE_SHADER_MIXED_FLOAT_DOT_PRODUCT_SPEC_VERSION},
+    {"VK_KHR_acceleration_structure", VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION},
+    {"VK_KHR_ray_tracing_pipeline", VK_KHR_RAY_TRACING_PIPELINE_SPEC_VERSION},
+    {"VK_KHR_ray_query", VK_KHR_RAY_QUERY_SPEC_VERSION},
+    {"VK_EXT_mesh_shader", VK_EXT_MESH_SHADER_SPEC_VERSION},
+};
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo* pCreateInfo,
+                                                     const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount,
+                                                               VkPhysicalDevice* pPhysicalDevices);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
+                                                                    VkFormatProperties* pFormatProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
+                                                                             VkImageType type, VkImageTiling tiling,
+                                                                             VkImageUsageFlags usage, VkImageCreateFlags flags,
+                                                                             VkImageFormatProperties* pImageFormatProperties);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
+                                                              VkPhysicalDeviceProperties* pProperties);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
+                                                                         uint32_t* pQueueFamilyPropertyCount,
+                                                                         VkQueueFamilyProperties* pQueueFamilyProperties);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,
+                                                                    VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+
+static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char* pName);
+
+static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char* pName);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo,
+                                                   const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount,
+                                                                           VkExtensionProperties* pProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName,
+                                                                         uint32_t* pPropertyCount,
+                                                                         VkExtensionProperties* pProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount,
+                                                                     VkLayerProperties* pProperties);
+
+static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
+
+static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
+
+static VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle(VkQueue queue);
+
+static VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle(VkDevice device);
+
+static VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo,
+                                                     const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
+
+static VKAPI_ATTR void VKAPI_CALL FreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL MapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size,
+                                                VkMemoryMapFlags flags, void** ppData);
+
+static VKAPI_ATTR void VKAPI_CALL UnmapMemory(VkDevice device, VkDeviceMemory memory);
+
+static VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
+                                                              const VkMappedMemoryRange* pMemoryRanges);
+
+static VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
+                                                                   const VkMappedMemoryRange* pMemoryRanges);
+
+static VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
+                                                            VkDeviceSize* pCommittedMemoryInBytes);
+
+static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory,
+                                                       VkDeviceSize memoryOffset);
+
+static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory,
+                                                      VkDeviceSize memoryOffset);
+
+static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
+                                                              VkMemoryRequirements* pMemoryRequirements);
+
+static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements(VkDevice device, VkImage image,
+                                                             VkMemoryRequirements* pMemoryRequirements);
+
+static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements(VkDevice device, VkImage image,
+                                                                   uint32_t* pSparseMemoryRequirementCount,
+                                                                   VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
+                                                                               VkImageType type, VkSampleCountFlagBits samples,
+                                                                               VkImageUsageFlags usage, VkImageTiling tiling,
+                                                                               uint32_t* pPropertyCount,
+                                                                               VkSparseImageFormatProperties* pProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo,
+                                                      VkFence fence);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo,
+                                                  const VkAllocationCallbacks* pAllocator, VkFence* pFence);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus(VkDevice device, VkFence fence);
+
+static VKAPI_ATTR VkResult VKAPI_CALL WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll,
+                                                    uint64_t timeout);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo,
+                                                      const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
+
+static VKAPI_ATTR void VKAPI_CALL DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo,
+                                                      const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
+                                                          uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride,
+                                                          VkQueryResultFlags flags);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo,
+                                                   const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo,
+                                                  const VkAllocationCallbacks* pAllocator, VkImage* pImage);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource,
+                                                            VkSubresourceLayout* pLayout);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo,
+                                                      const VkAllocationCallbacks* pAllocator, VkImageView* pView);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo,
+                                                        const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(VkDevice device, VkCommandPool commandPool,
+                                                     const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
+
+static VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo,
+                                                             VkCommandBuffer* pCommandBuffers);
+
+static VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount,
+                                                     const VkCommandBuffer* pCommandBuffers);
+
+static VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(VkCommandBuffer commandBuffer);
+
+static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer,
+                                                uint32_t regionCount, const VkBufferCopy* pRegions);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
+                                               VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
+                                               const VkImageCopy* pRegions);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
+                                                       VkImageLayout dstImageLayout, uint32_t regionCount,
+                                                       const VkBufferImageCopy* pRegions);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
+                                                       VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount,
+                                                       const VkBufferImageCopy* pRegions);
+
+static VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
+                                                  VkDeviceSize dataSize, const void* pData);
+
+static VKAPI_ATTR void VKAPI_CALL CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
+                                                VkDeviceSize size, uint32_t data);
+
+static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
+                                                     VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
+                                                     uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers,
+                                                     uint32_t bufferMemoryBarrierCount,
+                                                     const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+                                                     uint32_t imageMemoryBarrierCount,
+                                                     const VkImageMemoryBarrier* pImageMemoryBarriers);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query,
+                                                VkQueryControlFlags flags);
+
+static VKAPI_ATTR void VKAPI_CALL CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
+
+static VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
+                                                    uint32_t queryCount);
+
+static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage,
+                                                    VkQueryPool queryPool, uint32_t query);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
+                                                          uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset,
+                                                          VkDeviceSize stride, VkQueryResultFlags flags);
+
+static VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount,
+                                                     const VkCommandBuffer* pCommandBuffers);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo,
+                                                  const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus(VkDevice device, VkEvent event);
+
+static VKAPI_ATTR VkResult VKAPI_CALL SetEvent(VkDevice device, VkEvent event);
+
+static VKAPI_ATTR VkResult VKAPI_CALL ResetEvent(VkDevice device, VkEvent event);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo,
+                                                       const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyBufferView(VkDevice device, VkBufferView bufferView,
+                                                    const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo,
+                                                         const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
+                                                      const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo,
+                                                          const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
+                                                       const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize,
+                                                           void* pData);
+
+static VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount,
+                                                          const VkPipelineCache* pSrcCaches);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache,
+                                                             uint32_t createInfoCount,
+                                                             const VkComputePipelineCreateInfo* pCreateInfos,
+                                                             const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo,
+                                                           const VkAllocationCallbacks* pAllocator,
+                                                           VkPipelineLayout* pPipelineLayout);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
+                                                        const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo,
+                                                    const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
+
+static VKAPI_ATTR void VKAPI_CALL DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+                                                                const VkAllocationCallbacks* pAllocator,
+                                                                VkDescriptorSetLayout* pSetLayout);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout,
+                                                             const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo,
+                                                           const VkAllocationCallbacks* pAllocator,
+                                                           VkDescriptorPool* pDescriptorPool);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+                                                        const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+                                                          VkDescriptorPoolResetFlags flags);
+
+static VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo,
+                                                             VkDescriptorSet* pDescriptorSets);
+
+static VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
+                                                         uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
+
+static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
+                                                       const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount,
+                                                       const VkCopyDescriptorSet* pDescriptorCopies);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
+                                                  VkPipeline pipeline);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
+                                                        VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount,
+                                                        const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount,
+                                                        const uint32_t* pDynamicOffsets);
+
+static VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
+                                                     const VkClearColorValue* pColor, uint32_t rangeCount,
+                                                     const VkImageSubresourceRange* pRanges);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY,
+                                              uint32_t groupCountZ);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+
+static VKAPI_ATTR void VKAPI_CALL CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+
+static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents,
+                                                VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask,
+                                                uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers,
+                                                uint32_t bufferMemoryBarrierCount,
+                                                const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+                                                uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
+
+static VKAPI_ATTR void VKAPI_CALL CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
+                                                   VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size,
+                                                   const void* pValues);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
+                                                              uint32_t createInfoCount,
+                                                              const VkGraphicsPipelineCreateInfo* pCreateInfos,
+                                                              const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo,
+                                                        const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
+                                                     const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo,
+                                                       const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(VkDevice device, VkRenderPass renderPass,
+                                                    const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount,
+                                                 const VkViewport* pViewports);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount,
+                                                const VkRect2D* pScissors);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor,
+                                                  float depthBiasClamp, float depthBiasSlopeFactor);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+                                                           uint32_t compareMask);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+                                                         uint32_t writeMask);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+                                                         uint32_t reference);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                     VkIndexType indexType);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount,
+                                                       const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount,
+                                          uint32_t firstVertex, uint32_t firstInstance);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount,
+                                                 uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                  uint32_t drawCount, uint32_t stride);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                         uint32_t drawCount, uint32_t stride);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
+                                               VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
+                                               const VkImageBlit* pRegions, VkFilter filter);
+
+static VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
+                                                            const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount,
+                                                            const VkImageSubresourceRange* pRanges);
+
+static VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
+                                                      const VkClearAttachment* pAttachments, uint32_t rectCount,
+                                                      const VkClearRect* pRects);
+
+static VKAPI_ATTR void VKAPI_CALL CmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
+                                                  VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
+                                                  const VkImageResolve* pRegions);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin,
+                                                     VkSubpassContents contents);
+
+static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents);
+
+static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass(VkCommandBuffer commandBuffer);
+
+static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceVersion(uint32_t* pApiVersion);
+
+static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
+                                                        const VkBindBufferMemoryInfo* pBindInfos);
+
+static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2(VkDevice device, uint32_t bindInfoCount,
+                                                       const VkBindImageMemoryInfo* pBindInfos);
+
+static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex,
+                                                                   uint32_t remoteDeviceIndex,
+                                                                   VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask);
+
+static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroups(
+    VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
+
+static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo,
+                                                              VkMemoryRequirements2* pMemoryRequirements);
+
+static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo,
+                                                               VkMemoryRequirements2* pMemoryRequirements);
+
+static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2(VkDevice device,
+                                                                    const VkImageSparseMemoryRequirementsInfo2* pInfo,
+                                                                    uint32_t* pSparseMemoryRequirementCount,
+                                                                    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
+                                                               VkPhysicalDeviceProperties2* pProperties);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format,
+                                                                     VkFormatProperties2* pFormatProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL
+GetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+                                        VkImageFormatProperties2* pImageFormatProperties);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice,
+                                                                          uint32_t* pQueueFamilyPropertyCount,
+                                                                          VkQueueFamilyProperties2* pQueueFamilyProperties);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice,
+                                                                     VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount,
+    VkSparseImageFormatProperties2* pProperties);
+
+static VKAPI_ATTR void VKAPI_CALL TrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);
+
+static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferProperties(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+    VkExternalBufferProperties* pExternalBufferProperties);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFenceProperties(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+    VkExternalFenceProperties* pExternalFenceProperties);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphoreProperties(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+    VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY,
+                                                  uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY,
+                                                  uint32_t groupCountZ);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplate(VkDevice device,
+                                                                     const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+                                                                     const VkAllocationCallbacks* pAllocator,
+                                                                     VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplate(VkDevice device,
+                                                                  VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+                                                                  const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet,
+                                                                  VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+                                                                  const void* pData);
+
+static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+                                                                VkDescriptorSetLayoutSupport* pSupport);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversion(VkDevice device,
+                                                                   const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+                                                                   const VkAllocationCallbacks* pAllocator,
+                                                                   VkSamplerYcbcrConversion* pYcbcrConversion);
+
+static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
+                                                                const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR void VKAPI_CALL ResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue);
+
+static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout);
+
+static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo);
+
+static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);
+
+static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);
+
+static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddress(VkDevice device,
+                                                                          const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                       VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+                                                       uint32_t stride);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                              VkBuffer countBuffer, VkDeviceSize countBufferOffset,
+                                                              uint32_t maxDrawCount, uint32_t stride);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo,
+                                                        const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin,
+                                                      const VkSubpassBeginInfo* pSubpassBeginInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo,
+                                                  const VkSubpassEndInfo* pSubpassEndInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
+                                                                      VkPhysicalDeviceToolProperties* pToolProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo,
+                                                            const VkAllocationCallbacks* pAllocator,
+                                                            VkPrivateDataSlot* pPrivateDataSlot);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot,
+                                                         const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
+                                                     VkPrivateDataSlot privateDataSlot, uint64_t data);
+
+static VKAPI_ATTR void VKAPI_CALL GetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
+                                                 VkPrivateDataSlot privateDataSlot, uint64_t* pData);
+
+static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage,
+                                                     VkQueryPool queryPool, uint32_t query);
+
+static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits,
+                                                   VkFence fence);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2(VkCommandBuffer commandBuffer,
+                                                        const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2(VkCommandBuffer commandBuffer,
+                                                        const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo);
+
+static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo,
+                                                                    VkMemoryRequirements2* pMemoryRequirements);
+
+static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
+                                                                   VkMemoryRequirements2* pMemoryRequirements);
+
+static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirements(
+    VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount,
+    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event,
+                                               const VkDependencyInfo* pDependencyInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask);
+
+static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents,
+                                                 const VkDependencyInfo* pDependencyInfos);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdEndRendering(VkCommandBuffer commandBuffer);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount,
+                                                          const VkViewport* pViewports);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount,
+                                                         const VkRect2D* pScissors);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount,
+                                                        const VkBuffer* pBuffers, const VkDeviceSize* pOffsets,
+                                                        const VkDeviceSize* pSizes, const VkDeviceSize* pStrides);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp,
+                                                  VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable);
+
+static VKAPI_ATTR VkResult VKAPI_CALL MapMemory2(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData);
+
+static VKAPI_ATTR VkResult VKAPI_CALL UnmapMemory2(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo);
+
+static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSubresourceLayout(VkDevice device, const VkDeviceImageSubresourceInfo* pInfo,
+                                                                  VkSubresourceLayout2* pLayout);
+
+static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2(VkDevice device, VkImage image,
+                                                             const VkImageSubresource2* pSubresource,
+                                                             VkSubresourceLayout2* pLayout);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToImage(VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToMemory(VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToImage(VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL TransitionImageLayout(VkDevice device, uint32_t transitionCount,
+                                                            const VkHostImageLayoutTransitionInfo* pTransitions);
+
+static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
+                                                       VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount,
+                                                       const VkWriteDescriptorSet* pDescriptorWrites);
+
+static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplate(VkCommandBuffer commandBuffer,
+                                                                   VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+                                                                   VkPipelineLayout layout, uint32_t set, const void* pData);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets2(VkCommandBuffer commandBuffer,
+                                                         const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdPushConstants2(VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet2(VkCommandBuffer commandBuffer,
+                                                        const VkPushDescriptorSetInfo* pPushDescriptorSetInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplate2(
+    VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetLineStipple(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
+                                                    uint16_t lineStipplePattern);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer2(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                      VkDeviceSize size, VkIndexType indexType);
+
+static VKAPI_ATTR void VKAPI_CALL GetRenderingAreaGranularity(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo,
+                                                              VkExtent2D* pGranularity);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingAttachmentLocations(VkCommandBuffer commandBuffer,
+                                                                     const VkRenderingAttachmentLocationInfo* pLocationInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingInputAttachmentIndices(
+    VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo);
+
+static VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
+                                                    const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
+                                                                         VkSurfaceKHR surface, VkBool32* pSupported);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+                                                                              VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+                                                                         uint32_t* pSurfaceFormatCount,
+                                                                         VkSurfaceFormatKHR* pSurfaceFormats);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+                                                                              uint32_t* pPresentModeCount,
+                                                                              VkPresentModeKHR* pPresentModes);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo,
+                                                         const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain);
+
+static VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
+                                                      const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain,
+                                                            uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
+
+static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout,
+                                                          VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
+
+static VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL
+GetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface,
+                                                                           VkDeviceGroupPresentModeFlagsKHR* pModes);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+                                                                            uint32_t* pRectCount, VkRect2D* pRects);
+
+static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo,
+                                                           uint32_t* pImageIndex);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,
+                                                                            uint32_t* pPropertyCount,
+                                                                            VkDisplayPropertiesKHR* pProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice,
+                                                                                 uint32_t* pPropertyCount,
+                                                                                 VkDisplayPlanePropertiesKHR* pProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex,
+                                                                          uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
+                                                                  uint32_t* pPropertyCount,
+                                                                  VkDisplayModePropertiesKHR* pProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
+                                                           const VkDisplayModeCreateInfoKHR* pCreateInfo,
+                                                           const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode,
+                                                                     uint32_t planeIndex,
+                                                                     VkDisplayPlaneCapabilitiesKHR* pCapabilities);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR(VkInstance instance,
+                                                                   const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
+                                                                   const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount,
+                                                                const VkSwapchainCreateInfoKHR* pCreateInfos,
+                                                                const VkAllocationCallbacks* pAllocator,
+                                                                VkSwapchainKHR* pSwapchains);
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
+                                                           const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                                  uint32_t queueFamilyIndex, Display* dpy,
+                                                                                  VisualID visualID);
+#endif /* VK_USE_PLATFORM_XLIB_KHR */
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+static VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
+                                                          const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                                 uint32_t queueFamilyIndex,
+                                                                                 xcb_connection_t* connection,
+                                                                                 xcb_visualid_t visual_id);
+#endif /* VK_USE_PLATFORM_XCB_KHR */
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+static VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
+                                                              const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                                     uint32_t queueFamilyIndex,
+                                                                                     struct wl_display* display);
+#endif /* VK_USE_PLATFORM_WAYLAND_KHR */
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+static VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+                                                              const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+#endif /* VK_USE_PLATFORM_ANDROID_KHR */
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+static VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
+                                                            const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                                   uint32_t queueFamilyIndex);
+#endif /* VK_USE_PLATFORM_WIN32_KHR */
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice,
+                                                                            const VkVideoProfileInfoKHR* pVideoProfile,
+                                                                            VkVideoCapabilitiesKHR* pCapabilities);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoFormatPropertiesKHR(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo,
+    uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionKHR(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo,
+                                                            const VkAllocationCallbacks* pAllocator,
+                                                            VkVideoSessionKHR* pVideoSession);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession,
+                                                         const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL
+GetVideoSessionMemoryRequirementsKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount,
+                                     VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements);
+
+static VKAPI_ATTR VkResult VKAPI_CALL BindVideoSessionMemoryKHR(VkDevice device, VkVideoSessionKHR videoSession,
+                                                                uint32_t bindSessionMemoryInfoCount,
+                                                                const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionParametersKHR(VkDevice device,
+                                                                      const VkVideoSessionParametersCreateInfoKHR* pCreateInfo,
+                                                                      const VkAllocationCallbacks* pAllocator,
+                                                                      VkVideoSessionParametersKHR* pVideoSessionParameters);
+
+static VKAPI_ATTR VkResult VKAPI_CALL UpdateVideoSessionParametersKHR(VkDevice device,
+                                                                      VkVideoSessionParametersKHR videoSessionParameters,
+                                                                      const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionParametersKHR(VkDevice device,
+                                                                   VkVideoSessionParametersKHR videoSessionParameters,
+                                                                   const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer,
+                                                         const VkVideoBeginCodingInfoKHR* pBeginInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdEndVideoCodingKHR(VkCommandBuffer commandBuffer,
+                                                       const VkVideoEndCodingInfoKHR* pEndCodingInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdControlVideoCodingKHR(VkCommandBuffer commandBuffer,
+                                                           const VkVideoCodingControlInfoKHR* pCodingControlInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdEndRenderingKHR(VkCommandBuffer commandBuffer);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice,
+                                                                VkPhysicalDeviceFeatures2* pFeatures);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,
+                                                                  VkPhysicalDeviceProperties2* pProperties);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format,
+                                                                        VkFormatProperties2* pFormatProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+    VkImageFormatProperties2* pImageFormatProperties);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice,
+                                                                             uint32_t* pQueueFamilyPropertyCount,
+                                                                             VkQueueFamilyProperties2* pQueueFamilyProperties);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice,
+                                                                        VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount,
+    VkSparseImageFormatProperties2* pProperties);
+
+static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex,
+                                                                      uint32_t localDeviceIndex, uint32_t remoteDeviceIndex,
+                                                                      VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY,
+                                                     uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY,
+                                                     uint32_t groupCountZ);
+
+static VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);
+
+static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHR(
+    VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+    VkExternalBufferProperties* pExternalBufferProperties);
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR(VkDevice device,
+                                                              const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+                                                              HANDLE* pHandle);
+
+static VKAPI_ATTR VkResult VKAPI_CALL
+GetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle,
+                                  VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
+#endif /* VK_USE_PLATFORM_WIN32_KHR */
+static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType,
+                                                               int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+    VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+static VKAPI_ATTR VkResult VKAPI_CALL
+ImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR(VkDevice device,
+                                                                 const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+                                                                 HANDLE* pHandle);
+#endif /* VK_USE_PLATFORM_WIN32_KHR */
+static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR(VkDevice device,
+                                                           const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd);
+
+static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
+                                                          VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount,
+                                                          const VkWriteDescriptorSet* pDescriptorWrites);
+
+static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer,
+                                                                      VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+                                                                      VkPipelineLayout layout, uint32_t set, const void* pData);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(VkDevice device,
+                                                                        const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+                                                                        const VkAllocationCallbacks* pAllocator,
+                                                                        VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(VkDevice device,
+                                                                     VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+                                                                     const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet,
+                                                                     VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+                                                                     const void* pData);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo,
+                                                           const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,
+                                                         const VkRenderPassBeginInfo* pRenderPassBegin,
+                                                         const VkSubpassBeginInfo* pSubpassBeginInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo,
+                                                     const VkSubpassEndInfo* pSubpassEndInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+    VkExternalFenceProperties* pExternalFenceProperties);
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR(VkDevice device,
+                                                                const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR(VkDevice device,
+                                                             const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+                                                             HANDLE* pHandle);
+#endif /* VK_USE_PLATFORM_WIN32_KHR */
+static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd);
+
+static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
+    VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters,
+    VkPerformanceCounterDescriptionKHR* pCounterDescriptions);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
+    VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses);
+
+static VKAPI_ATTR VkResult VKAPI_CALL AcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo);
+
+static VKAPI_ATTR void VKAPI_CALL ReleaseProfilingLockKHR(VkDevice device);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice,
+                                                                               const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+                                                                               VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice,
+                                                                          const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+                                                                          uint32_t* pSurfaceFormatCount,
+                                                                          VkSurfaceFormat2KHR* pSurfaceFormats);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice,
+                                                                             uint32_t* pPropertyCount,
+                                                                             VkDisplayProperties2KHR* pProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice,
+                                                                                  uint32_t* pPropertyCount,
+                                                                                  VkDisplayPlaneProperties2KHR* pProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
+                                                                   uint32_t* pPropertyCount,
+                                                                   VkDisplayModeProperties2KHR* pProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice,
+                                                                      const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
+                                                                      VkDisplayPlaneCapabilities2KHR* pCapabilities);
+
+static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo,
+                                                                 VkMemoryRequirements2* pMemoryRequirements);
+
+static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo,
+                                                                  VkMemoryRequirements2* pMemoryRequirements);
+
+static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR(VkDevice device,
+                                                                       const VkImageSparseMemoryRequirementsInfo2* pInfo,
+                                                                       uint32_t* pSparseMemoryRequirementCount,
+                                                                       VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversionKHR(VkDevice device,
+                                                                      const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+                                                                      const VkAllocationCallbacks* pAllocator,
+                                                                      VkSamplerYcbcrConversion* pYcbcrConversion);
+
+static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
+                                                                   const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount,
+                                                           const VkBindBufferMemoryInfo* pBindInfos);
+
+static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount,
+                                                          const VkBindImageMemoryInfo* pBindInfos);
+
+static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupportKHR(VkDevice device,
+                                                                   const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+                                                                   VkDescriptorSetLayoutSupport* pSupport);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                          VkBuffer countBuffer, VkDeviceSize countBufferOffset,
+                                                          uint32_t maxDrawCount, uint32_t stride);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                                                 VkDeviceSize offset, VkBuffer countBuffer,
+                                                                 VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+                                                                 uint32_t stride);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t* pValue);
+
+static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout);
+
+static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL
+GetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount,
+                                         VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize,
+                                                               const VkFragmentShadingRateCombinerOpKHR combinerOps[2]);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingAttachmentLocationsKHR(VkCommandBuffer commandBuffer,
+                                                                        const VkRenderingAttachmentLocationInfo* pLocationInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingInputAttachmentIndicesKHR(
+    VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL WaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId,
+                                                        uint64_t timeout);
+
+static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);
+
+static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);
+
+static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device,
+                                                                             const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks* pAllocator,
+                                                                 VkDeferredOperationKHR* pDeferredOperation);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation,
+                                                              const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR uint32_t VKAPI_CALL GetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation);
+
+static VKAPI_ATTR VkResult VKAPI_CALL DeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo,
+                                                                         uint32_t* pExecutableCount,
+                                                                         VkPipelineExecutablePropertiesKHR* pProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableStatisticsKHR(VkDevice device,
+                                                                         const VkPipelineExecutableInfoKHR* pExecutableInfo,
+                                                                         uint32_t* pStatisticCount,
+                                                                         VkPipelineExecutableStatisticKHR* pStatistics);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableInternalRepresentationsKHR(
+    VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount,
+    VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
+
+static VKAPI_ATTR VkResult VKAPI_CALL MapMemory2KHR(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData);
+
+static VKAPI_ATTR VkResult VKAPI_CALL UnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo,
+    VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL
+GetEncodedVideoSessionParametersKHR(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo,
+                                    VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData);
+
+static VKAPI_ATTR void VKAPI_CALL CmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
+                                                  const VkDependencyInfo* pDependencyInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask);
+
+static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents,
+                                                    const VkDependencyInfo* pDependencyInfos);
+
+static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage,
+                                                        VkQueryPool queryPool, uint32_t query);
+
+static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits,
+                                                      VkFence fence);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer3KHR(VkCommandBuffer commandBuffer, const VkBindIndexBuffer3InfoKHR* pInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers3KHR(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+                                                           uint32_t bindingCount, const VkBindVertexBuffer3InfoKHR* pBindingInfos);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect2KHR(VkCommandBuffer commandBuffer, const VkDrawIndirect2InfoKHR* pInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect2KHR(VkCommandBuffer commandBuffer, const VkDrawIndirect2InfoKHR* pInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect2KHR(VkCommandBuffer commandBuffer, const VkDispatchIndirect2InfoKHR* pInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyDeviceMemoryInfoKHR* pCopyMemoryInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToImageKHR(VkCommandBuffer commandBuffer,
+                                                          const VkCopyDeviceMemoryImageInfoKHR* pCopyMemoryInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToMemoryKHR(VkCommandBuffer commandBuffer,
+                                                          const VkCopyDeviceMemoryImageInfoKHR* pCopyMemoryInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdUpdateMemoryKHR(VkCommandBuffer commandBuffer, const VkDeviceAddressRangeKHR* pDstRange,
+                                                     VkAddressCommandFlagsKHR dstFlags, VkDeviceSize dataSize, const void* pData);
+
+static VKAPI_ATTR void VKAPI_CALL CmdFillMemoryKHR(VkCommandBuffer commandBuffer, const VkDeviceAddressRangeKHR* pDstRange,
+                                                   VkAddressCommandFlagsKHR dstFlags, uint32_t data);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResultsToMemoryKHR(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                                                                     uint32_t firstQuery, uint32_t queryCount,
+                                                                     const VkStridedDeviceAddressRangeKHR* pDstRange,
+                                                                     VkAddressCommandFlagsKHR dstFlags,
+                                                                     VkQueryResultFlags queryResultFlags);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCount2KHR(VkCommandBuffer commandBuffer, const VkDrawIndirectCount2InfoKHR* pInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCount2KHR(VkCommandBuffer commandBuffer,
+                                                                  const VkDrawIndirectCount2InfoKHR* pInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBeginConditionalRendering2EXT(
+    VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfo2EXT* pConditionalRenderingBegin);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+                                                                      uint32_t bindingCount,
+                                                                      const VkBindTransformFeedbackBuffer2InfoEXT* pBindingInfos);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedback2EXT(VkCommandBuffer commandBuffer, uint32_t firstCounterRange,
+                                                                uint32_t counterRangeCount,
+                                                                const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfos);
+
+static VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedback2EXT(VkCommandBuffer commandBuffer, uint32_t firstCounterRange,
+                                                              uint32_t counterRangeCount,
+                                                              const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfos);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectByteCount2EXT(VkCommandBuffer commandBuffer, uint32_t instanceCount,
+                                                               uint32_t firstInstance,
+                                                               const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfo,
+                                                               uint32_t counterOffset, uint32_t vertexStride);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirect2EXT(VkCommandBuffer commandBuffer, const VkDrawIndirect2InfoKHR* pInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCount2EXT(VkCommandBuffer commandBuffer,
+                                                                    const VkDrawIndirectCount2InfoKHR* pInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdWriteMarkerToMemoryAMD(VkCommandBuffer commandBuffer, const VkMemoryMarkerInfoAMD* pInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructure2KHR(VkDevice device,
+                                                                      const VkAccelerationStructureCreateInfo2KHR* pCreateInfo,
+                                                                      const VkAllocationCallbacks* pAllocator,
+                                                                      VkAccelerationStructureKHR* pAccelerationStructure);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer,
+                                                           const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer,
+                                                           const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirect2KHR(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress);
+
+static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirementsKHR(VkDevice device,
+                                                                       const VkDeviceBufferMemoryRequirements* pInfo,
+                                                                       VkMemoryRequirements2* pMemoryRequirements);
+
+static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
+                                                                      VkMemoryRequirements2* pMemoryRequirements);
+
+static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirementsKHR(
+    VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount,
+    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                         VkDeviceSize size, VkIndexType indexType);
+
+static VKAPI_ATTR void VKAPI_CALL GetRenderingAreaGranularityKHR(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo,
+                                                                 VkExtent2D* pGranularity);
+
+static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSubresourceLayoutKHR(VkDevice device, const VkDeviceImageSubresourceInfo* pInfo,
+                                                                     VkSubresourceLayout2* pLayout);
+
+static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2KHR(VkDevice device, VkImage image,
+                                                                const VkImageSubresource2* pSubresource,
+                                                                VkSubresourceLayout2* pLayout);
+
+static VKAPI_ATTR VkResult VKAPI_CALL WaitForPresent2KHR(VkDevice device, VkSwapchainKHR swapchain,
+                                                         const VkPresentWait2InfoKHR* pPresentWait2Info);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineBinariesKHR(VkDevice device, const VkPipelineBinaryCreateInfoKHR* pCreateInfo,
+                                                                const VkAllocationCallbacks* pAllocator,
+                                                                VkPipelineBinaryHandlesInfoKHR* pBinaries);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyPipelineBinaryKHR(VkDevice device, VkPipelineBinaryKHR pipelineBinary,
+                                                           const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineKeyKHR(VkDevice device, const VkPipelineCreateInfoKHR* pPipelineCreateInfo,
+                                                        VkPipelineBinaryKeyKHR* pPipelineKey);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineBinaryDataKHR(VkDevice device, const VkPipelineBinaryDataInfoKHR* pInfo,
+                                                               VkPipelineBinaryKeyKHR* pPipelineBinaryKey,
+                                                               size_t* pPipelineBinaryDataSize, void* pPipelineBinaryData);
+
+static VKAPI_ATTR VkResult VKAPI_CALL ReleaseCapturedPipelineDataKHR(VkDevice device,
+                                                                     const VkReleaseCapturedPipelineDataInfoKHR* pInfo,
+                                                                     const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL ReleaseSwapchainImagesKHR(VkDevice device,
+                                                                const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesKHR(
+    VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleKHR(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
+                                                       uint16_t lineStipplePattern);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice,
+                                                                                   uint32_t* pTimeDomainCount,
+                                                                                   VkTimeDomainKHR* pTimeDomains);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampCount,
+                                                                 const VkCalibratedTimestampInfoKHR* pTimestampInfos,
+                                                                 uint64_t* pTimestamps, uint64_t* pMaxDeviation);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer,
+                                                            const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdPushConstants2KHR(VkCommandBuffer commandBuffer,
+                                                       const VkPushConstantsInfo* pPushConstantsInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer,
+                                                           const VkPushDescriptorSetInfo* pPushDescriptorSetInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplate2KHR(
+    VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetDescriptorBufferOffsets2EXT(
+    VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBufferEmbeddedSamplers2EXT(
+    VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryIndirectKHR(VkCommandBuffer commandBuffer,
+                                                           const VkCopyMemoryIndirectInfoKHR* pCopyMemoryIndirectInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToImageIndirectKHR(
+    VkCommandBuffer commandBuffer, const VkCopyMemoryToImageIndirectInfoKHR* pCopyMemoryToImageIndirectInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceFaultReportsKHR(VkDevice device, uint64_t timeout, uint32_t* pFaultCounts,
+                                                               VkDeviceFaultInfoKHR* pFaultInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceFaultDebugInfoKHR(VkDevice device, VkDeviceFaultDebugInfoKHR* pDebugInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdEndRendering2KHR(VkCommandBuffer commandBuffer,
+                                                      const VkRenderingEndInfoKHR* pRenderingEndInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(VkInstance instance,
+                                                                   const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
+                                                                   const VkAllocationCallbacks* pAllocator,
+                                                                   VkDebugReportCallbackEXT* pCallback);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback,
+                                                                const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
+                                                        VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location,
+                                                        int32_t messageCode, const char* pLayerPrefix, const char* pMessage);
+
+static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer,
+                                                         const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer,
+                                                          const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+                                                                     uint32_t bindingCount, const VkBuffer* pBuffers,
+                                                                     const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer,
+                                                               uint32_t counterBufferCount, const VkBuffer* pCounterBuffers,
+                                                               const VkDeviceSize* pCounterBufferOffsets);
+
+static VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer,
+                                                             uint32_t counterBufferCount, const VkBuffer* pCounterBuffers,
+                                                             const VkDeviceSize* pCounterBufferOffsets);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query,
+                                                          VkQueryControlFlags flags, uint32_t index);
+
+static VKAPI_ATTR void VKAPI_CALL CmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query,
+                                                        uint32_t index);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount,
+                                                              uint32_t firstInstance, VkBuffer counterBuffer,
+                                                              VkDeviceSize counterBufferOffset, uint32_t counterOffset,
+                                                              uint32_t vertexStride);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo,
+                                                        const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo,
+                                                          const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module,
+                                                     const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function,
+                                                       const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo);
+
+static VKAPI_ATTR uint32_t VKAPI_CALL GetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo);
+
+static VKAPI_ATTR uint64_t VKAPI_CALL GetImageViewHandle64NVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetImageViewAddressNVX(VkDevice device, VkImageView imageView,
+                                                             VkImageViewAddressPropertiesNVX* pProperties);
+
+static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceCombinedImageSamplerIndexNVX(VkDevice device, uint64_t imageViewIndex,
+                                                                            uint64_t samplerIndex);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                          VkBuffer countBuffer, VkDeviceSize countBufferOffset,
+                                                          uint32_t maxDrawCount, uint32_t stride);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                                                 VkDeviceSize offset, VkBuffer countBuffer,
+                                                                 VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+                                                                 uint32_t stride);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage,
+                                                       VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo);
+#ifdef VK_USE_PLATFORM_GGP
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateStreamDescriptorSurfaceGGP(VkInstance instance,
+                                                                       const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
+                                                                       const VkAllocationCallbacks* pAllocator,
+                                                                       VkSurfaceKHR* pSurface);
+#endif /* VK_USE_PLATFORM_GGP */
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceExternalImageFormatPropertiesNV(
+    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage,
+    VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType,
+    VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory,
+                                                             VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
+#endif /* VK_USE_PLATFORM_WIN32_KHR */
+
+#ifdef VK_USE_PLATFORM_VI_NN
+static VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo,
+                                                        const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+#endif /* VK_USE_PLATFORM_VI_NN */
+static VKAPI_ATTR void VKAPI_CALL CmdBeginConditionalRenderingEXT(
+    VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
+
+static VKAPI_ATTR void VKAPI_CALL CmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport,
+                                                           uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings);
+
+static VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+
+static VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput,
+                                                               VkDisplayKHR* pDisplay);
+#endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice,
+                                                                               VkSurfaceKHR surface,
+                                                                               VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
+
+static VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT(VkDevice device, VkDisplayKHR display,
+                                                             const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo,
+                                                             const VkAllocationCallbacks* pAllocator, VkFence* pFence);
+
+static VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display,
+                                                              const VkDisplayEventInfoEXT* pDisplayEventInfo,
+                                                              const VkAllocationCallbacks* pAllocator, VkFence* pFence);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain,
+                                                             VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain,
+                                                                    VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain,
+                                                                      uint32_t* pPresentationTimingCount,
+                                                                      VkPastPresentationTimingGOOGLE* pPresentationTimings);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle,
+                                                            uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleModeEXT(VkCommandBuffer commandBuffer,
+                                                                VkDiscardRectangleModeEXT discardRectangleMode);
+
+static VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains,
+                                                    const VkHdrMetadataEXT* pMetadata);
+#ifdef VK_USE_PLATFORM_IOS_MVK
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
+                                                          const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+#endif /* VK_USE_PLATFORM_IOS_MVK */
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+static VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
+                                                            const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+#endif /* VK_USE_PLATFORM_MACOS_MVK */
+static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo);
+
+static VKAPI_ATTR void VKAPI_CALL QueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo);
+
+static VKAPI_ATTR void VKAPI_CALL QueueEndDebugUtilsLabelEXT(VkQueue queue);
+
+static VKAPI_ATTR void VKAPI_CALL QueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer);
+
+static VKAPI_ATTR void VKAPI_CALL CmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer,
+                                                              const VkDebugUtilsLabelEXT* pLabelInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT(VkInstance instance,
+                                                                   const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
+                                                                   const VkAllocationCallbacks* pAllocator,
+                                                                   VkDebugUtilsMessengerEXT* pMessenger);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger,
+                                                                const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR void VKAPI_CALL SubmitDebugUtilsMessageEXT(VkInstance instance,
+                                                             VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+                                                             VkDebugUtilsMessageTypeFlagsEXT messageTypes,
+                                                             const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetAndroidHardwareBufferPropertiesANDROID(
+    VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryAndroidHardwareBufferANDROID(
+    VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer);
+#endif /* VK_USE_PLATFORM_ANDROID_KHR */
+
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+static VKAPI_ATTR VkResult VKAPI_CALL CreateExecutionGraphPipelinesAMDX(VkDevice device, VkPipelineCache pipelineCache,
+                                                                        uint32_t createInfoCount,
+                                                                        const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos,
+                                                                        const VkAllocationCallbacks* pAllocator,
+                                                                        VkPipeline* pPipelines);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetExecutionGraphPipelineScratchSizeAMDX(VkDevice device, VkPipeline executionGraph,
+                                                                               VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetExecutionGraphPipelineNodeIndexAMDX(
+    VkDevice device, VkPipeline executionGraph, const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, uint32_t* pNodeIndex);
+
+static VKAPI_ATTR void VKAPI_CALL CmdInitializeGraphScratchMemoryAMDX(VkCommandBuffer commandBuffer, VkPipeline executionGraph,
+                                                                      VkDeviceAddress scratch, VkDeviceSize scratchSize);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDispatchGraphAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch,
+                                                       VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDispatchGraphIndirectAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch,
+                                                               VkDeviceSize scratchSize,
+                                                               const VkDispatchGraphCountInfoAMDX* pCountInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDispatchGraphIndirectCountAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch,
+                                                                    VkDeviceSize scratchSize, VkDeviceAddress countInfo);
+#endif /* VK_ENABLE_BETA_EXTENSIONS */
+static VKAPI_ATTR VkResult VKAPI_CALL WriteSamplerDescriptorsEXT(VkDevice device, uint32_t samplerCount,
+                                                                 const VkSamplerCreateInfo* pSamplers,
+                                                                 const VkHostAddressRangeEXT* pDescriptors);
+
+static VKAPI_ATTR VkResult VKAPI_CALL WriteResourceDescriptorsEXT(VkDevice device, uint32_t resourceCount,
+                                                                  const VkResourceDescriptorInfoEXT* pResources,
+                                                                  const VkHostAddressRangeEXT* pDescriptors);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBindSamplerHeapEXT(VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBindResourceHeapEXT(VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdPushDataEXT(VkCommandBuffer commandBuffer, const VkPushDataInfoEXT* pPushDataInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetImageOpaqueCaptureDataEXT(VkDevice device, uint32_t imageCount, const VkImage* pImages,
+                                                                   VkHostAddressRangeEXT* pDatas);
+
+static VKAPI_ATTR VkDeviceSize VKAPI_CALL GetPhysicalDeviceDescriptorSizeEXT(VkPhysicalDevice physicalDevice,
+                                                                             VkDescriptorType descriptorType);
+
+static VKAPI_ATTR VkResult VKAPI_CALL RegisterCustomBorderColorEXT(VkDevice device,
+                                                                   const VkSamplerCustomBorderColorCreateInfoEXT* pBorderColor,
+                                                                   VkBool32 requestIndex, uint32_t* pIndex);
+
+static VKAPI_ATTR void VKAPI_CALL UnregisterCustomBorderColorEXT(VkDevice device, uint32_t index);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetTensorOpaqueCaptureDataARM(VkDevice device, uint32_t tensorCount,
+                                                                    const VkTensorARM* pTensors, VkHostAddressRangeEXT* pDatas);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer,
+                                                           const VkSampleLocationsInfoEXT* pSampleLocationsInfo);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice,
+                                                                            VkSampleCountFlagBits samples,
+                                                                            VkMultisamplePropertiesEXT* pMultisampleProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image,
+                                                                             VkImageDrmFormatModifierPropertiesEXT* pProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo,
+                                                               const VkAllocationCallbacks* pAllocator,
+                                                               VkValidationCacheEXT* pValidationCache);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache,
+                                                            const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL MergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache,
+                                                               uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache,
+                                                                size_t* pDataSize, void* pData);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView,
+                                                            VkImageLayout imageLayout);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport,
+                                                                     uint32_t viewportCount,
+                                                                     const VkShadingRatePaletteNV* pShadingRatePalettes);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer,
+                                                            VkCoarseSampleOrderTypeNV sampleOrderType,
+                                                            uint32_t customSampleOrderCount,
+                                                            const VkCoarseSampleOrderCustomNV* pCustomSampleOrders);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureNV(VkDevice device,
+                                                                    const VkAccelerationStructureCreateInfoNV* pCreateInfo,
+                                                                    const VkAllocationCallbacks* pAllocator,
+                                                                    VkAccelerationStructureNV* pAccelerationStructure);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure,
+                                                                 const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureMemoryRequirementsNV(
+    VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements);
+
+static VKAPI_ATTR VkResult VKAPI_CALL BindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount,
+                                                                        const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer,
+                                                                  const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData,
+                                                                  VkDeviceSize instanceOffset, VkBool32 update,
+                                                                  VkAccelerationStructureNV dst, VkAccelerationStructureNV src,
+                                                                  VkBuffer scratch, VkDeviceSize scratchOffset);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst,
+                                                                 VkAccelerationStructureNV src,
+                                                                 VkCopyAccelerationStructureModeKHR mode);
+
+static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer,
+                                                 VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer,
+                                                 VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride,
+                                                 VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset,
+                                                 VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer,
+                                                 VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride,
+                                                 uint32_t width, uint32_t height, uint32_t depth);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache,
+                                                                  uint32_t createInfoCount,
+                                                                  const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
+                                                                  const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup,
+                                                                         uint32_t groupCount, size_t dataSize, void* pData);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup,
+                                                                        uint32_t groupCount, size_t dataSize, void* pData);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureHandleNV(VkDevice device,
+                                                                       VkAccelerationStructureNV accelerationStructure,
+                                                                       size_t dataSize, void* pData);
+
+static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesNV(
+    VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures,
+    VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader);
+
+static VKAPI_ATTR VkResult VKAPI_CALL
+GetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer,
+                                  VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);
+
+static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage,
+                                                          VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker);
+
+static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage,
+                                                           VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice,
+                                                                                   uint32_t* pTimeDomainCount,
+                                                                                   VkTimeDomainKHR* pTimeDomains);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount,
+                                                                 const VkCalibratedTimestampInfoKHR* pTimestampInfos,
+                                                                 uint64_t* pTimestamps, uint64_t* pMaxDeviation);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                             uint32_t drawCount, uint32_t stride);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                                                  VkDeviceSize offset, VkBuffer countBuffer,
+                                                                  VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+                                                                  uint32_t stride);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorEnableNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor,
+                                                                 uint32_t exclusiveScissorCount,
+                                                                 const VkBool32* pExclusiveScissorEnables);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor,
+                                                           uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker);
+
+static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount,
+                                                           VkCheckpointDataNV* pCheckpointData);
+
+static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount,
+                                                            VkCheckpointData2NV* pCheckpointData);
+
+static VKAPI_ATTR VkResult VKAPI_CALL SetSwapchainPresentTimingQueueSizeEXT(VkDevice device, VkSwapchainKHR swapchain,
+                                                                            uint32_t size);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainTimingPropertiesEXT(VkDevice device, VkSwapchainKHR swapchain,
+                                                                      VkSwapchainTimingPropertiesEXT* pSwapchainTimingProperties,
+                                                                      uint64_t* pSwapchainTimingPropertiesCounter);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainTimeDomainPropertiesEXT(
+    VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimeDomainPropertiesEXT* pSwapchainTimeDomainProperties,
+    uint64_t* pTimeDomainsCounter);
+
+static VKAPI_ATTR VkResult VKAPI_CALL
+GetPastPresentationTimingEXT(VkDevice device, const VkPastPresentationTimingInfoEXT* pPastPresentationTimingInfo,
+                             VkPastPresentationTimingPropertiesEXT* pPastPresentationTimingProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL InitializePerformanceApiINTEL(VkDevice device,
+                                                                    const VkInitializePerformanceApiInfoINTEL* pInitializeInfo);
+
+static VKAPI_ATTR void VKAPI_CALL UninitializePerformanceApiINTEL(VkDevice device);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer,
+                                                                   const VkPerformanceMarkerInfoINTEL* pMarkerInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer,
+                                                                         const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer,
+                                                                     const VkPerformanceOverrideInfoINTEL* pOverrideInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL
+AcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
+                                     VkPerformanceConfigurationINTEL* pConfiguration);
+
+static VKAPI_ATTR VkResult VKAPI_CALL ReleasePerformanceConfigurationINTEL(VkDevice device,
+                                                                           VkPerformanceConfigurationINTEL configuration);
+
+static VKAPI_ATTR VkResult VKAPI_CALL QueueSetPerformanceConfigurationINTEL(VkQueue queue,
+                                                                            VkPerformanceConfigurationINTEL configuration);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter,
+                                                                   VkPerformanceValueINTEL* pValue);
+
+static VKAPI_ATTR void VKAPI_CALL SetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable);
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateImagePipeSurfaceFUCHSIA(VkInstance instance,
+                                                                    const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
+                                                                    const VkAllocationCallbacks* pAllocator,
+                                                                    VkSurfaceKHR* pSurface);
+#endif /* VK_USE_PLATFORM_FUCHSIA */
+
+#ifdef VK_USE_PLATFORM_METAL_EXT
+static VKAPI_ATTR VkResult VKAPI_CALL CreateMetalSurfaceEXT(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
+                                                            const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+#endif /* VK_USE_PLATFORM_METAL_EXT */
+static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
+                                                                         VkPhysicalDeviceToolProperties* pToolProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice,
+                                                                                     uint32_t* pPropertyCount,
+                                                                                     VkCooperativeMatrixPropertiesNV* pProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
+    VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations);
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDevice physicalDevice,
+                                                                               const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+                                                                               uint32_t* pPresentModeCount,
+                                                                               VkPresentModeKHR* pPresentModes);
+
+static VKAPI_ATTR VkResult VKAPI_CALL AcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain);
+
+static VKAPI_ATTR VkResult VKAPI_CALL ReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModes2EXT(VkDevice device,
+                                                                            const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+                                                                            VkDeviceGroupPresentModeFlagsKHR* pModes);
+#endif /* VK_USE_PLATFORM_WIN32_KHR */
+static VKAPI_ATTR VkResult VKAPI_CALL CreateHeadlessSurfaceEXT(VkInstance instance,
+                                                               const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,
+                                                               const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
+                                                       uint16_t lineStipplePattern);
+
+static VKAPI_ATTR void VKAPI_CALL ResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
+                                                    uint32_t queryCount);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount,
+                                                             const VkViewport* pViewports);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount,
+                                                            const VkRect2D* pScissors);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+                                                           uint32_t bindingCount, const VkBuffer* pBuffers,
+                                                           const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes,
+                                                           const VkDeviceSize* pStrides);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp,
+                                                     VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToImageEXT(VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToMemoryEXT(VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToImageEXT(VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL TransitionImageLayoutEXT(VkDevice device, uint32_t transitionCount,
+                                                               const VkHostImageLayoutTransitionInfo* pTransitions);
+
+static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2EXT(VkDevice device, VkImage image,
+                                                                const VkImageSubresource2* pSubresource,
+                                                                VkSubresourceLayout2* pLayout);
+
+static VKAPI_ATTR VkResult VKAPI_CALL ReleaseSwapchainImagesEXT(VkDevice device,
+                                                                const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo);
+
+static VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsNV(VkDevice device,
+                                                                           const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo,
+                                                                           VkMemoryRequirements2* pMemoryRequirements);
+
+static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer,
+                                                                   const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed,
+                                                                const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
+                                                               VkPipeline pipeline, uint32_t groupIndex);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNV(VkDevice device,
+                                                                     const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,
+                                                                     const VkAllocationCallbacks* pAllocator,
+                                                                     VkIndirectCommandsLayoutNV* pIndirectCommandsLayout);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNV(VkDevice device,
+                                                                  VkIndirectCommandsLayoutNV indirectCommandsLayout,
+                                                                  const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias2EXT(VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT* pDepthBiasInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL AcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId,
+                                                       VkDisplayKHR* display);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo,
+                                                               const VkAllocationCallbacks* pAllocator,
+                                                               VkPrivateDataSlot* pPrivateDataSlot);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot,
+                                                            const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
+                                                        VkPrivateDataSlot privateDataSlot, uint64_t data);
+
+static VKAPI_ATTR void VKAPI_CALL GetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
+                                                    VkPrivateDataSlot privateDataSlot, uint64_t* pData);
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateCudaModuleNV(VkDevice device, const VkCudaModuleCreateInfoNV* pCreateInfo,
+                                                         const VkAllocationCallbacks* pAllocator, VkCudaModuleNV* pModule);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetCudaModuleCacheNV(VkDevice device, VkCudaModuleNV module, size_t* pCacheSize,
+                                                           void* pCacheData);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateCudaFunctionNV(VkDevice device, const VkCudaFunctionCreateInfoNV* pCreateInfo,
+                                                           const VkAllocationCallbacks* pAllocator, VkCudaFunctionNV* pFunction);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyCudaModuleNV(VkDevice device, VkCudaModuleNV module,
+                                                      const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyCudaFunctionNV(VkDevice device, VkCudaFunctionNV function,
+                                                        const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCudaLaunchKernelNV(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo);
+#endif /* VK_ENABLE_BETA_EXTENSIONS */
+static VKAPI_ATTR void VKAPI_CALL CmdDispatchTileQCOM(VkCommandBuffer commandBuffer,
+                                                      const VkDispatchTileInfoQCOM* pDispatchTileInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBeginPerTileExecutionQCOM(VkCommandBuffer commandBuffer,
+                                                               const VkPerTileBeginInfoQCOM* pPerTileBeginInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdEndPerTileExecutionQCOM(VkCommandBuffer commandBuffer,
+                                                             const VkPerTileEndInfoQCOM* pPerTileEndInfo);
+#ifdef VK_USE_PLATFORM_METAL_EXT
+
+static VKAPI_ATTR void VKAPI_CALL ExportMetalObjectsEXT(VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo);
+#endif /* VK_USE_PLATFORM_METAL_EXT */
+static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout,
+                                                                VkDeviceSize* pLayoutSizeInBytes);
+
+static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout,
+                                                                         uint32_t binding, VkDeviceSize* pOffset);
+
+static VKAPI_ATTR void VKAPI_CALL GetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize,
+                                                   void* pDescriptor);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount,
+                                                              const VkDescriptorBufferBindingInfoEXT* pBindingInfos);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer,
+                                                                   VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
+                                                                   uint32_t firstSet, uint32_t setCount,
+                                                                   const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer,
+                                                                             VkPipelineBindPoint pipelineBindPoint,
+                                                                             VkPipelineLayout layout, uint32_t set);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device,
+                                                                              const VkBufferCaptureDescriptorDataInfoEXT* pInfo,
+                                                                              void* pData);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetImageOpaqueCaptureDescriptorDataEXT(VkDevice device,
+                                                                             const VkImageCaptureDescriptorDataInfoEXT* pInfo,
+                                                                             void* pData);
+
+static VKAPI_ATTR VkResult VKAPI_CALL
+GetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetSamplerOpaqueCaptureDescriptorDataEXT(VkDevice device,
+                                                                               const VkSamplerCaptureDescriptorDataInfoEXT* pInfo,
+                                                                               void* pData);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureOpaqueCaptureDescriptorDataEXT(
+    VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer,
+                                                                  VkFragmentShadingRateNV shadingRate,
+                                                                  const VkFragmentShadingRateCombinerOpKHR combinerOps[2]);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceFaultInfoEXT(VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts,
+                                                            VkDeviceFaultInfoEXT* pFaultInfo);
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+static VKAPI_ATTR VkResult VKAPI_CALL AcquireWinrtDisplayNV(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetWinrtDisplayNV(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId,
+                                                        VkDisplayKHR* pDisplay);
+#endif /* VK_USE_PLATFORM_WIN32_KHR */
+
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDirectFBSurfaceEXT(VkInstance instance,
+                                                               const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo,
+                                                               const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceDirectFBPresentationSupportEXT(VkPhysicalDevice physicalDevice,
+                                                                                      uint32_t queueFamilyIndex, IDirectFB* dfb);
+#endif /* VK_USE_PLATFORM_DIRECTFB_EXT */
+static VKAPI_ATTR void VKAPI_CALL CmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount,
+                                                       const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions,
+                                                       uint32_t vertexAttributeDescriptionCount,
+                                                       const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions);
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandleFUCHSIA(VkDevice device,
+                                                                   const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+                                                                   zx_handle_t* pZirconHandle);
+
+static VKAPI_ATTR VkResult VKAPI_CALL
+GetMemoryZirconHandlePropertiesFUCHSIA(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle,
+                                       VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreZirconHandleFUCHSIA(
+    VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreZirconHandleFUCHSIA(
+    VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferCollectionFUCHSIA(VkDevice device,
+                                                                    const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo,
+                                                                    const VkAllocationCallbacks* pAllocator,
+                                                                    VkBufferCollectionFUCHSIA* pCollection);
+
+static VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionImageConstraintsFUCHSIA(
+    VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionBufferConstraintsFUCHSIA(
+    VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyBufferCollectionFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection,
+                                                                 const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetBufferCollectionPropertiesFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection,
+                                                                           VkBufferCollectionPropertiesFUCHSIA* pProperties);
+#endif /* VK_USE_PLATFORM_FUCHSIA */
+static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass,
+                                                                                    VkExtent2D* pMaxWorkgroupSize);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView,
+                                                              VkImageLayout imageLayout);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryRemoteAddressNV(VkDevice device,
+                                                               const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo,
+                                                               VkRemoteAddressNV* pAddress);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfoEXT* pPipelineInfo,
+                                                               VkBaseOutStructure* pPipelineProperties);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable);
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateScreenSurfaceQNX(VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo,
+                                                             const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice,
+                                                                                    uint32_t queueFamilyIndex,
+                                                                                    struct _screen_window* window);
+#endif /* VK_USE_PLATFORM_SCREEN_QNX */
+static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
+                                                            const VkBool32* pColorWriteEnables);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount,
+                                                  const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount,
+                                                  uint32_t firstInstance, uint32_t stride);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount,
+                                                         const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount,
+                                                         uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo,
+                                                        const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap,
+                                                     const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32_t infoCount,
+                                                       const VkMicromapBuildInfoEXT* pInfos);
+
+static VKAPI_ATTR VkResult VKAPI_CALL BuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR deferredOperation,
+                                                        uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation,
+                                                      const VkCopyMicromapInfoEXT* pInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation,
+                                                              const VkCopyMicromapToMemoryInfoEXT* pInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation,
+                                                              const VkCopyMemoryToMicromapInfoEXT* pInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL WriteMicromapsPropertiesEXT(VkDevice device, uint32_t micromapCount,
+                                                                  const VkMicromapEXT* pMicromaps, VkQueryType queryType,
+                                                                  size_t dataSize, void* pData, size_t stride);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer,
+                                                             const VkCopyMicromapToMemoryInfoEXT* pInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer,
+                                                             const VkCopyMemoryToMicromapInfoEXT* pInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, uint32_t micromapCount,
+                                                                 const VkMicromapEXT* pMicromaps, VkQueryType queryType,
+                                                                 VkQueryPool queryPool, uint32_t firstQuery);
+
+static VKAPI_ATTR void VKAPI_CALL GetDeviceMicromapCompatibilityEXT(VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo,
+                                                                    VkAccelerationStructureCompatibilityKHR* pCompatibility);
+
+static VKAPI_ATTR void VKAPI_CALL GetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType,
+                                                           const VkMicromapBuildInfoEXT* pBuildInfo,
+                                                           VkMicromapBuildSizesInfoEXT* pSizeInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawClusterHUAWEI(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY,
+                                                       uint32_t groupCountZ);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawClusterIndirectHUAWEI(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
+
+static VKAPI_ATTR void VKAPI_CALL SetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority);
+
+static VKAPI_ATTR void VKAPI_CALL
+GetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference,
+                                           VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping);
+
+static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void** ppData);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress,
+                                                          uint32_t copyCount, uint32_t stride);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress,
+                                                                 uint32_t copyCount, uint32_t stride, VkImage dstImage,
+                                                                 VkImageLayout dstImageLayout,
+                                                                 const VkImageSubresourceLayers* pImageSubresources);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryNV(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount,
+                                                        const VkDecompressMemoryRegionNV* pDecompressMemoryRegions);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryIndirectCountNV(VkCommandBuffer commandBuffer,
+                                                                     VkDeviceAddress indirectCommandsAddress,
+                                                                     VkDeviceAddress indirectCommandsCountAddress, uint32_t stride);
+
+static VKAPI_ATTR void VKAPI_CALL GetPipelineIndirectMemoryRequirementsNV(VkDevice device,
+                                                                          const VkComputePipelineCreateInfo* pCreateInfo,
+                                                                          VkMemoryRequirements2* pMemoryRequirements);
+
+static VKAPI_ATTR void VKAPI_CALL CmdUpdatePipelineIndirectBufferNV(VkCommandBuffer commandBuffer,
+                                                                    VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
+
+static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetPipelineIndirectDeviceAddressNV(VkDevice device,
+                                                                                const VkPipelineIndirectDeviceAddressInfoNV* pInfo);
+#ifdef VK_USE_PLATFORM_OHOS
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer,
+                                                                    VkNativeBufferPropertiesOHOS* pProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo,
+                                                                struct OH_NativeBuffer** pBuffer);
+#endif /* VK_USE_PLATFORM_OHOS */
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer,
+                                                                VkSampleCountFlagBits rasterizationSamples);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples,
+                                                      const VkSampleMask* pSampleMask);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment,
+                                                            uint32_t attachmentCount, const VkBool32* pColorBlendEnables);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment,
+                                                              uint32_t attachmentCount,
+                                                              const VkColorBlendEquationEXT* pColorBlendEquations);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment,
+                                                          uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer,
+                                                                    VkTessellationDomainOrigin domainOrigin);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetConservativeRasterizationModeEXT(
+    VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer,
+                                                                            float extraPrimitiveOverestimationSize);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment,
+                                                              uint32_t attachmentCount,
+                                                              const VkColorBlendAdvancedEXT* pColorBlendAdvanced);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer,
+                                                               VkProvokingVertexModeEXT provokingVertexMode);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer,
+                                                                 VkLineRasterizationModeEXT lineRasterizationMode);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport,
+                                                          uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer,
+                                                                 VkCoverageModulationModeNV coverageModulationMode);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer,
+                                                                        VkBool32 coverageModulationTableEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer,
+                                                                  uint32_t coverageModulationTableCount,
+                                                                  const float* pCoverageModulationTable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer,
+                                                                           VkBool32 representativeFragmentTestEnable);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer,
+                                                                VkCoverageReductionModeNV coverageReductionMode);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateTensorARM(VkDevice device, const VkTensorCreateInfoARM* pCreateInfo,
+                                                      const VkAllocationCallbacks* pAllocator, VkTensorARM* pTensor);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyTensorARM(VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateTensorViewARM(VkDevice device, const VkTensorViewCreateInfoARM* pCreateInfo,
+                                                          const VkAllocationCallbacks* pAllocator, VkTensorViewARM* pView);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyTensorViewARM(VkDevice device, VkTensorViewARM tensorView,
+                                                       const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR void VKAPI_CALL GetTensorMemoryRequirementsARM(VkDevice device, const VkTensorMemoryRequirementsInfoARM* pInfo,
+                                                                 VkMemoryRequirements2* pMemoryRequirements);
+
+static VKAPI_ATTR VkResult VKAPI_CALL BindTensorMemoryARM(VkDevice device, uint32_t bindInfoCount,
+                                                          const VkBindTensorMemoryInfoARM* pBindInfos);
+
+static VKAPI_ATTR void VKAPI_CALL GetDeviceTensorMemoryRequirementsARM(VkDevice device,
+                                                                       const VkDeviceTensorMemoryRequirementsARM* pInfo,
+                                                                       VkMemoryRequirements2* pMemoryRequirements);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyTensorARM(VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM* pCopyTensorInfo);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalTensorPropertiesARM(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalTensorInfoARM* pExternalTensorInfo,
+    VkExternalTensorPropertiesARM* pExternalTensorProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetTensorOpaqueCaptureDescriptorDataARM(VkDevice device,
+                                                                              const VkTensorCaptureDescriptorDataInfoARM* pInfo,
+                                                                              void* pData);
+
+static VKAPI_ATTR VkResult VKAPI_CALL
+GetTensorViewOpaqueCaptureDescriptorDataARM(VkDevice device, const VkTensorViewCaptureDescriptorDataInfoARM* pInfo, void* pData);
+
+static VKAPI_ATTR void VKAPI_CALL GetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule,
+                                                               VkShaderModuleIdentifierEXT* pIdentifier);
+
+static VKAPI_ATTR void VKAPI_CALL GetShaderModuleCreateInfoIdentifierEXT(VkDevice device,
+                                                                         const VkShaderModuleCreateInfo* pCreateInfo,
+                                                                         VkShaderModuleIdentifierEXT* pIdentifier);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceOpticalFlowImageFormatsNV(
+    VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount,
+    VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateOpticalFlowSessionNV(VkDevice device,
+                                                                 const VkOpticalFlowSessionCreateInfoNV* pCreateInfo,
+                                                                 const VkAllocationCallbacks* pAllocator,
+                                                                 VkOpticalFlowSessionNV* pSession);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionNV session,
+                                                              const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL BindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSessionNV session,
+                                                                    VkOpticalFlowSessionBindingPointNV bindingPoint,
+                                                                    VkImageView view, VkImageLayout layout);
+
+static VKAPI_ATTR void VKAPI_CALL CmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session,
+                                                          const VkOpticalFlowExecuteInfoNV* pExecuteInfo);
+
+static VKAPI_ATTR void VKAPI_CALL AntiLagUpdateAMD(VkDevice device, const VkAntiLagDataAMD* pData);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateShadersEXT(VkDevice device, uint32_t createInfoCount,
+                                                       const VkShaderCreateInfoEXT* pCreateInfos,
+                                                       const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyShaderEXT(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetShaderBinaryDataEXT(VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBindShadersEXT(VkCommandBuffer commandBuffer, uint32_t stageCount,
+                                                    const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampRangeEXT(VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode,
+                                                           const VkDepthClampRangeEXT* pDepthClampRange);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer,
+                                                                       uint32_t* pPropertiesCount,
+                                                                       VkTilePropertiesQCOM* pProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo,
+                                                                            VkTilePropertiesQCOM* pProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeVectorPropertiesNV(VkPhysicalDevice physicalDevice,
+                                                                                     uint32_t* pPropertyCount,
+                                                                                     VkCooperativeVectorPropertiesNV* pProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL ConvertCooperativeVectorMatrixNV(VkDevice device,
+                                                                       const VkConvertCooperativeVectorMatrixInfoNV* pInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdConvertCooperativeVectorMatrixNV(VkCommandBuffer commandBuffer, uint32_t infoCount,
+                                                                      const VkConvertCooperativeVectorMatrixInfoNV* pInfos);
+
+static VKAPI_ATTR VkResult VKAPI_CALL SetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain,
+                                                            const VkLatencySleepModeInfoNV* pSleepModeInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL LatencySleepNV(VkDevice device, VkSwapchainKHR swapchain,
+                                                     const VkLatencySleepInfoNV* pSleepInfo);
+
+static VKAPI_ATTR void VKAPI_CALL SetLatencyMarkerNV(VkDevice device, VkSwapchainKHR swapchain,
+                                                     const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo);
+
+static VKAPI_ATTR void VKAPI_CALL GetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain,
+                                                      VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo);
+
+static VKAPI_ATTR void VKAPI_CALL QueueNotifyOutOfBandNV(VkQueue queue, const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDataGraphPipelinesARM(VkDevice device, VkDeferredOperationKHR deferredOperation,
+                                                                  VkPipelineCache pipelineCache, uint32_t createInfoCount,
+                                                                  const VkDataGraphPipelineCreateInfoARM* pCreateInfos,
+                                                                  const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDataGraphPipelineSessionARM(VkDevice device,
+                                                                        const VkDataGraphPipelineSessionCreateInfoARM* pCreateInfo,
+                                                                        const VkAllocationCallbacks* pAllocator,
+                                                                        VkDataGraphPipelineSessionARM* pSession);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetDataGraphPipelineSessionBindPointRequirementsARM(
+    VkDevice device, const VkDataGraphPipelineSessionBindPointRequirementsInfoARM* pInfo, uint32_t* pBindPointRequirementCount,
+    VkDataGraphPipelineSessionBindPointRequirementARM* pBindPointRequirements);
+
+static VKAPI_ATTR void VKAPI_CALL GetDataGraphPipelineSessionMemoryRequirementsARM(
+    VkDevice device, const VkDataGraphPipelineSessionMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements);
+
+static VKAPI_ATTR VkResult VKAPI_CALL BindDataGraphPipelineSessionMemoryARM(
+    VkDevice device, uint32_t bindInfoCount, const VkBindDataGraphPipelineSessionMemoryInfoARM* pBindInfos);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyDataGraphPipelineSessionARM(VkDevice device, VkDataGraphPipelineSessionARM session,
+                                                                     const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDispatchDataGraphARM(VkCommandBuffer commandBuffer, VkDataGraphPipelineSessionARM session,
+                                                          const VkDataGraphPipelineDispatchInfoARM* pInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetDataGraphPipelineAvailablePropertiesARM(VkDevice device,
+                                                                                 const VkDataGraphPipelineInfoARM* pPipelineInfo,
+                                                                                 uint32_t* pPropertiesCount,
+                                                                                 VkDataGraphPipelinePropertyARM* pProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetDataGraphPipelinePropertiesARM(VkDevice device,
+                                                                        const VkDataGraphPipelineInfoARM* pPipelineInfo,
+                                                                        uint32_t propertiesCount,
+                                                                        VkDataGraphPipelinePropertyQueryResultARM* pProperties);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(
+    VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pQueueFamilyDataGraphPropertyCount,
+    VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties);
+
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM* pQueueFamilyDataGraphProcessingEngineInfo,
+    VkQueueFamilyDataGraphProcessingEnginePropertiesARM* pQueueFamilyDataGraphProcessingEngineProperties);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer,
+                                                                        VkImageAspectFlags aspectMask);
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetScreenBufferPropertiesQNX(VkDevice device, const struct _screen_buffer* buffer,
+                                                                   VkScreenBufferPropertiesQNX* pProperties);
+#endif /* VK_USE_PLATFORM_SCREEN_QNX */
+static VKAPI_ATTR void VKAPI_CALL CmdBindTileMemoryQCOM(VkCommandBuffer commandBuffer,
+                                                        const VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryEXT(VkCommandBuffer commandBuffer,
+                                                         const VkDecompressMemoryInfoEXT* pDecompressMemoryInfoEXT);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryIndirectCountEXT(VkCommandBuffer commandBuffer,
+                                                                      VkMemoryDecompressionMethodFlagsEXT decompressionMethod,
+                                                                      VkDeviceAddress indirectCommandsAddress,
+                                                                      VkDeviceAddress indirectCommandsCountAddress,
+                                                                      uint32_t maxDecompressionCount, uint32_t stride);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateExternalComputeQueueNV(VkDevice device,
+                                                                   const VkExternalComputeQueueCreateInfoNV* pCreateInfo,
+                                                                   const VkAllocationCallbacks* pAllocator,
+                                                                   VkExternalComputeQueueNV* pExternalQueue);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyExternalComputeQueueNV(VkDevice device, VkExternalComputeQueueNV externalQueue,
+                                                                const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR void VKAPI_CALL GetExternalComputeQueueDataNV(VkExternalComputeQueueNV externalQueue,
+                                                                VkExternalComputeQueueDataParamsNV* params, void* pData);
+
+static VKAPI_ATTR void VKAPI_CALL GetClusterAccelerationStructureBuildSizesNV(
+    VkDevice device, const VkClusterAccelerationStructureInputInfoNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBuildClusterAccelerationStructureIndirectNV(
+    VkCommandBuffer commandBuffer, const VkClusterAccelerationStructureCommandsInfoNV* pCommandInfos);
+
+static VKAPI_ATTR void VKAPI_CALL
+GetPartitionedAccelerationStructuresBuildSizesNV(VkDevice device, const VkPartitionedAccelerationStructureInstancesInputNV* pInfo,
+                                                 VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBuildPartitionedAccelerationStructuresNV(
+    VkCommandBuffer commandBuffer, const VkBuildPartitionedAccelerationStructureInfoNV* pBuildInfo);
+
+static VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsEXT(
+    VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, VkMemoryRequirements2* pMemoryRequirements);
+
+static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsEXT(VkCommandBuffer commandBuffer,
+                                                                    const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo,
+                                                                    VkCommandBuffer stateCommandBuffer);
+
+static VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsEXT(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed,
+                                                                 const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutEXT(VkDevice device,
+                                                                      const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo,
+                                                                      const VkAllocationCallbacks* pAllocator,
+                                                                      VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutEXT(VkDevice device,
+                                                                   VkIndirectCommandsLayoutEXT indirectCommandsLayout,
+                                                                   const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectExecutionSetEXT(VkDevice device,
+                                                                    const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo,
+                                                                    const VkAllocationCallbacks* pAllocator,
+                                                                    VkIndirectExecutionSetEXT* pIndirectExecutionSet);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyIndirectExecutionSetEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet,
+                                                                 const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR void VKAPI_CALL UpdateIndirectExecutionSetPipelineEXT(
+    VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount,
+    const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites);
+
+static VKAPI_ATTR void VKAPI_CALL UpdateIndirectExecutionSetShaderEXT(
+    VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount,
+    const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites);
+#ifdef VK_USE_PLATFORM_OHOS
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo,
+                                                        const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+#endif /* VK_USE_PLATFORM_OHOS */
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(
+    VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties);
+#ifdef VK_USE_PLATFORM_METAL_EXT
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryMetalHandleEXT(VkDevice device,
+                                                              const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo,
+                                                              void** pHandle);
+
+static VKAPI_ATTR VkResult VKAPI_CALL
+GetMemoryMetalHandlePropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHandle,
+                                  VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties);
+#endif /* VK_USE_PLATFORM_METAL_EXT */
+static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(
+    VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterARM* pCounters,
+    VkPerformanceCounterDescriptionARM* pCounterDescriptions);
+
+static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceShaderInstrumentationMetricsARM(
+    VkPhysicalDevice physicalDevice, uint32_t* pDescriptionCount, VkShaderInstrumentationMetricDescriptionARM* pDescriptions);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateShaderInstrumentationARM(VkDevice device,
+                                                                     const VkShaderInstrumentationCreateInfoARM* pCreateInfo,
+                                                                     const VkAllocationCallbacks* pAllocator,
+                                                                     VkShaderInstrumentationARM* pInstrumentation);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyShaderInstrumentationARM(VkDevice device, VkShaderInstrumentationARM instrumentation,
+                                                                  const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBeginShaderInstrumentationARM(VkCommandBuffer commandBuffer,
+                                                                   VkShaderInstrumentationARM instrumentation);
+
+static VKAPI_ATTR void VKAPI_CALL CmdEndShaderInstrumentationARM(VkCommandBuffer commandBuffer);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetShaderInstrumentationValuesARM(VkDevice device, VkShaderInstrumentationARM instrumentation,
+                                                                        uint32_t* pMetricBlockCount, void* pMetricValues,
+                                                                        VkShaderInstrumentationValuesFlagsARM flags);
+
+static VKAPI_ATTR void VKAPI_CALL ClearShaderInstrumentationMetricsARM(VkDevice device, VkShaderInstrumentationARM instrumentation);
+
+static VKAPI_ATTR void VKAPI_CALL CmdEndRendering2EXT(VkCommandBuffer commandBuffer,
+                                                      const VkRenderingEndInfoKHR* pRenderingEndInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBeginCustomResolveEXT(VkCommandBuffer commandBuffer,
+                                                           const VkBeginCustomResolveInfoEXT* pBeginCustomResolveInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetComputeOccupancyPriorityNV(VkCommandBuffer commandBuffer,
+                                                                   const VkComputeOccupancyPriorityParametersNV* pParameters);
+#ifdef VK_USE_PLATFORM_UBM_SEC
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateUbmSurfaceSEC(VkInstance instance, const VkUbmSurfaceCreateInfoSEC* pCreateInfo,
+                                                          const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceUbmPresentationSupportSEC(VkPhysicalDevice physicalDevice,
+                                                                                 uint32_t queueFamilyIndex,
+                                                                                 struct ubm_device* device);
+#endif /* VK_USE_PLATFORM_UBM_SEC */
+static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR(VkDevice device,
+                                                                     const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
+                                                                     const VkAllocationCallbacks* pAllocator,
+                                                                     VkAccelerationStructureKHR* pAccelerationStructure);
+
+static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure,
+                                                                  const VkAllocationCallbacks* pAllocator);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresKHR(
+    VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
+    const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);
+
+static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresIndirectKHR(
+    VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
+    const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts);
+
+static VKAPI_ATTR VkResult VKAPI_CALL
+BuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount,
+                               const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
+                               const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation,
+                                                                   const VkCopyAccelerationStructureInfoKHR* pInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureToMemoryKHR(VkDevice device,
+                                                                           VkDeferredOperationKHR deferredOperation,
+                                                                           const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToAccelerationStructureKHR(VkDevice device,
+                                                                           VkDeferredOperationKHR deferredOperation,
+                                                                           const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
+
+static VKAPI_ATTR VkResult VKAPI_CALL WriteAccelerationStructuresPropertiesKHR(
+    VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures,
+    VkQueryType queryType, size_t dataSize, void* pData, size_t stride);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer,
+                                                                  const VkCopyAccelerationStructureInfoKHR* pInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer,
+                                                                          const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer,
+                                                                          const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
+
+static VKAPI_ATTR VkDeviceAddress VKAPI_CALL
+GetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesKHR(
+    VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures,
+    VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery);
+
+static VKAPI_ATTR void VKAPI_CALL
+GetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo,
+                                               VkAccelerationStructureCompatibilityKHR* pCompatibility);
+
+static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureBuildSizesKHR(
+    VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo,
+    const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo);
+
+static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysKHR(VkCommandBuffer commandBuffer,
+                                                  const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
+                                                  const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
+                                                  const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
+                                                  const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
+                                                  uint32_t width, uint32_t height, uint32_t depth);
+
+static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation,
+                                                                   VkPipelineCache pipelineCache, uint32_t createInfoCount,
+                                                                   const VkRayTracingPipelineCreateInfoKHR* pCreateInfos,
+                                                                   const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
+
+static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline,
+                                                                                      uint32_t firstGroup, uint32_t groupCount,
+                                                                                      size_t dataSize, void* pData);
+
+static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer,
+                                                          const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
+                                                          const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
+                                                          const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
+                                                          const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
+                                                          VkDeviceAddress indirectDeviceAddress);
+
+static VKAPI_ATTR VkDeviceSize VKAPI_CALL GetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group,
+                                                                               VkShaderGroupShaderKHR groupShader);
+
+static VKAPI_ATTR void VKAPI_CALL CmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksEXT(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY,
+                                                      uint32_t groupCountZ);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                              uint32_t drawCount, uint32_t stride);
+
+static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountEXT(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                                                   VkDeviceSize offset, VkBuffer countBuffer,
+                                                                   VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+                                                                   uint32_t stride);
+// Map of all APIs to be intercepted by this layer
+static const std::unordered_map<std::string, void*> name_to_funcptr_map = {
+    {"vkCreateInstance", (void*)CreateInstance},
+    {"vkDestroyInstance", (void*)DestroyInstance},
+    {"vkEnumeratePhysicalDevices", (void*)EnumeratePhysicalDevices},
+    {"vkGetPhysicalDeviceFeatures", (void*)GetPhysicalDeviceFeatures},
+    {"vkGetPhysicalDeviceFormatProperties", (void*)GetPhysicalDeviceFormatProperties},
+    {"vkGetPhysicalDeviceImageFormatProperties", (void*)GetPhysicalDeviceImageFormatProperties},
+    {"vkGetPhysicalDeviceProperties", (void*)GetPhysicalDeviceProperties},
+    {"vkGetPhysicalDeviceQueueFamilyProperties", (void*)GetPhysicalDeviceQueueFamilyProperties},
+    {"vkGetPhysicalDeviceMemoryProperties", (void*)GetPhysicalDeviceMemoryProperties},
+    {"vkGetInstanceProcAddr", (void*)GetInstanceProcAddr},
+    {"vkGetDeviceProcAddr", (void*)GetDeviceProcAddr},
+    {"vkCreateDevice", (void*)CreateDevice},
+    {"vkDestroyDevice", (void*)DestroyDevice},
+    {"vkEnumerateInstanceExtensionProperties", (void*)EnumerateInstanceExtensionProperties},
+    {"vkEnumerateDeviceExtensionProperties", (void*)EnumerateDeviceExtensionProperties},
+    {"vkEnumerateInstanceLayerProperties", (void*)EnumerateInstanceLayerProperties},
+    {"vkEnumerateDeviceLayerProperties", (void*)EnumerateDeviceLayerProperties},
+    {"vkGetDeviceQueue", (void*)GetDeviceQueue},
+    {"vkQueueSubmit", (void*)QueueSubmit},
+    {"vkQueueWaitIdle", (void*)QueueWaitIdle},
+    {"vkDeviceWaitIdle", (void*)DeviceWaitIdle},
+    {"vkAllocateMemory", (void*)AllocateMemory},
+    {"vkFreeMemory", (void*)FreeMemory},
+    {"vkMapMemory", (void*)MapMemory},
+    {"vkUnmapMemory", (void*)UnmapMemory},
+    {"vkFlushMappedMemoryRanges", (void*)FlushMappedMemoryRanges},
+    {"vkInvalidateMappedMemoryRanges", (void*)InvalidateMappedMemoryRanges},
+    {"vkGetDeviceMemoryCommitment", (void*)GetDeviceMemoryCommitment},
+    {"vkBindBufferMemory", (void*)BindBufferMemory},
+    {"vkBindImageMemory", (void*)BindImageMemory},
+    {"vkGetBufferMemoryRequirements", (void*)GetBufferMemoryRequirements},
+    {"vkGetImageMemoryRequirements", (void*)GetImageMemoryRequirements},
+    {"vkGetImageSparseMemoryRequirements", (void*)GetImageSparseMemoryRequirements},
+    {"vkGetPhysicalDeviceSparseImageFormatProperties", (void*)GetPhysicalDeviceSparseImageFormatProperties},
+    {"vkQueueBindSparse", (void*)QueueBindSparse},
+    {"vkCreateFence", (void*)CreateFence},
+    {"vkDestroyFence", (void*)DestroyFence},
+    {"vkResetFences", (void*)ResetFences},
+    {"vkGetFenceStatus", (void*)GetFenceStatus},
+    {"vkWaitForFences", (void*)WaitForFences},
+    {"vkCreateSemaphore", (void*)CreateSemaphore},
+    {"vkDestroySemaphore", (void*)DestroySemaphore},
+    {"vkCreateQueryPool", (void*)CreateQueryPool},
+    {"vkDestroyQueryPool", (void*)DestroyQueryPool},
+    {"vkGetQueryPoolResults", (void*)GetQueryPoolResults},
+    {"vkCreateBuffer", (void*)CreateBuffer},
+    {"vkDestroyBuffer", (void*)DestroyBuffer},
+    {"vkCreateImage", (void*)CreateImage},
+    {"vkDestroyImage", (void*)DestroyImage},
+    {"vkGetImageSubresourceLayout", (void*)GetImageSubresourceLayout},
+    {"vkCreateImageView", (void*)CreateImageView},
+    {"vkDestroyImageView", (void*)DestroyImageView},
+    {"vkCreateCommandPool", (void*)CreateCommandPool},
+    {"vkDestroyCommandPool", (void*)DestroyCommandPool},
+    {"vkResetCommandPool", (void*)ResetCommandPool},
+    {"vkAllocateCommandBuffers", (void*)AllocateCommandBuffers},
+    {"vkFreeCommandBuffers", (void*)FreeCommandBuffers},
+    {"vkBeginCommandBuffer", (void*)BeginCommandBuffer},
+    {"vkEndCommandBuffer", (void*)EndCommandBuffer},
+    {"vkResetCommandBuffer", (void*)ResetCommandBuffer},
+    {"vkCmdCopyBuffer", (void*)CmdCopyBuffer},
+    {"vkCmdCopyImage", (void*)CmdCopyImage},
+    {"vkCmdCopyBufferToImage", (void*)CmdCopyBufferToImage},
+    {"vkCmdCopyImageToBuffer", (void*)CmdCopyImageToBuffer},
+    {"vkCmdUpdateBuffer", (void*)CmdUpdateBuffer},
+    {"vkCmdFillBuffer", (void*)CmdFillBuffer},
+    {"vkCmdPipelineBarrier", (void*)CmdPipelineBarrier},
+    {"vkCmdBeginQuery", (void*)CmdBeginQuery},
+    {"vkCmdEndQuery", (void*)CmdEndQuery},
+    {"vkCmdResetQueryPool", (void*)CmdResetQueryPool},
+    {"vkCmdWriteTimestamp", (void*)CmdWriteTimestamp},
+    {"vkCmdCopyQueryPoolResults", (void*)CmdCopyQueryPoolResults},
+    {"vkCmdExecuteCommands", (void*)CmdExecuteCommands},
+    {"vkCreateEvent", (void*)CreateEvent},
+    {"vkDestroyEvent", (void*)DestroyEvent},
+    {"vkGetEventStatus", (void*)GetEventStatus},
+    {"vkSetEvent", (void*)SetEvent},
+    {"vkResetEvent", (void*)ResetEvent},
+    {"vkCreateBufferView", (void*)CreateBufferView},
+    {"vkDestroyBufferView", (void*)DestroyBufferView},
+    {"vkCreateShaderModule", (void*)CreateShaderModule},
+    {"vkDestroyShaderModule", (void*)DestroyShaderModule},
+    {"vkCreatePipelineCache", (void*)CreatePipelineCache},
+    {"vkDestroyPipelineCache", (void*)DestroyPipelineCache},
+    {"vkGetPipelineCacheData", (void*)GetPipelineCacheData},
+    {"vkMergePipelineCaches", (void*)MergePipelineCaches},
+    {"vkCreateComputePipelines", (void*)CreateComputePipelines},
+    {"vkDestroyPipeline", (void*)DestroyPipeline},
+    {"vkCreatePipelineLayout", (void*)CreatePipelineLayout},
+    {"vkDestroyPipelineLayout", (void*)DestroyPipelineLayout},
+    {"vkCreateSampler", (void*)CreateSampler},
+    {"vkDestroySampler", (void*)DestroySampler},
+    {"vkCreateDescriptorSetLayout", (void*)CreateDescriptorSetLayout},
+    {"vkDestroyDescriptorSetLayout", (void*)DestroyDescriptorSetLayout},
+    {"vkCreateDescriptorPool", (void*)CreateDescriptorPool},
+    {"vkDestroyDescriptorPool", (void*)DestroyDescriptorPool},
+    {"vkResetDescriptorPool", (void*)ResetDescriptorPool},
+    {"vkAllocateDescriptorSets", (void*)AllocateDescriptorSets},
+    {"vkFreeDescriptorSets", (void*)FreeDescriptorSets},
+    {"vkUpdateDescriptorSets", (void*)UpdateDescriptorSets},
+    {"vkCmdBindPipeline", (void*)CmdBindPipeline},
+    {"vkCmdBindDescriptorSets", (void*)CmdBindDescriptorSets},
+    {"vkCmdClearColorImage", (void*)CmdClearColorImage},
+    {"vkCmdDispatch", (void*)CmdDispatch},
+    {"vkCmdDispatchIndirect", (void*)CmdDispatchIndirect},
+    {"vkCmdSetEvent", (void*)CmdSetEvent},
+    {"vkCmdResetEvent", (void*)CmdResetEvent},
+    {"vkCmdWaitEvents", (void*)CmdWaitEvents},
+    {"vkCmdPushConstants", (void*)CmdPushConstants},
+    {"vkCreateGraphicsPipelines", (void*)CreateGraphicsPipelines},
+    {"vkCreateFramebuffer", (void*)CreateFramebuffer},
+    {"vkDestroyFramebuffer", (void*)DestroyFramebuffer},
+    {"vkCreateRenderPass", (void*)CreateRenderPass},
+    {"vkDestroyRenderPass", (void*)DestroyRenderPass},
+    {"vkGetRenderAreaGranularity", (void*)GetRenderAreaGranularity},
+    {"vkCmdSetViewport", (void*)CmdSetViewport},
+    {"vkCmdSetScissor", (void*)CmdSetScissor},
+    {"vkCmdSetLineWidth", (void*)CmdSetLineWidth},
+    {"vkCmdSetDepthBias", (void*)CmdSetDepthBias},
+    {"vkCmdSetBlendConstants", (void*)CmdSetBlendConstants},
+    {"vkCmdSetDepthBounds", (void*)CmdSetDepthBounds},
+    {"vkCmdSetStencilCompareMask", (void*)CmdSetStencilCompareMask},
+    {"vkCmdSetStencilWriteMask", (void*)CmdSetStencilWriteMask},
+    {"vkCmdSetStencilReference", (void*)CmdSetStencilReference},
+    {"vkCmdBindIndexBuffer", (void*)CmdBindIndexBuffer},
+    {"vkCmdBindVertexBuffers", (void*)CmdBindVertexBuffers},
+    {"vkCmdDraw", (void*)CmdDraw},
+    {"vkCmdDrawIndexed", (void*)CmdDrawIndexed},
+    {"vkCmdDrawIndirect", (void*)CmdDrawIndirect},
+    {"vkCmdDrawIndexedIndirect", (void*)CmdDrawIndexedIndirect},
+    {"vkCmdBlitImage", (void*)CmdBlitImage},
+    {"vkCmdClearDepthStencilImage", (void*)CmdClearDepthStencilImage},
+    {"vkCmdClearAttachments", (void*)CmdClearAttachments},
+    {"vkCmdResolveImage", (void*)CmdResolveImage},
+    {"vkCmdBeginRenderPass", (void*)CmdBeginRenderPass},
+    {"vkCmdNextSubpass", (void*)CmdNextSubpass},
+    {"vkCmdEndRenderPass", (void*)CmdEndRenderPass},
+    {"vkEnumerateInstanceVersion", (void*)EnumerateInstanceVersion},
+    {"vkBindBufferMemory2", (void*)BindBufferMemory2},
+    {"vkBindImageMemory2", (void*)BindImageMemory2},
+    {"vkGetDeviceGroupPeerMemoryFeatures", (void*)GetDeviceGroupPeerMemoryFeatures},
+    {"vkCmdSetDeviceMask", (void*)CmdSetDeviceMask},
+    {"vkEnumeratePhysicalDeviceGroups", (void*)EnumeratePhysicalDeviceGroups},
+    {"vkGetImageMemoryRequirements2", (void*)GetImageMemoryRequirements2},
+    {"vkGetBufferMemoryRequirements2", (void*)GetBufferMemoryRequirements2},
+    {"vkGetImageSparseMemoryRequirements2", (void*)GetImageSparseMemoryRequirements2},
+    {"vkGetPhysicalDeviceFeatures2", (void*)GetPhysicalDeviceFeatures2},
+    {"vkGetPhysicalDeviceProperties2", (void*)GetPhysicalDeviceProperties2},
+    {"vkGetPhysicalDeviceFormatProperties2", (void*)GetPhysicalDeviceFormatProperties2},
+    {"vkGetPhysicalDeviceImageFormatProperties2", (void*)GetPhysicalDeviceImageFormatProperties2},
+    {"vkGetPhysicalDeviceQueueFamilyProperties2", (void*)GetPhysicalDeviceQueueFamilyProperties2},
+    {"vkGetPhysicalDeviceMemoryProperties2", (void*)GetPhysicalDeviceMemoryProperties2},
+    {"vkGetPhysicalDeviceSparseImageFormatProperties2", (void*)GetPhysicalDeviceSparseImageFormatProperties2},
+    {"vkTrimCommandPool", (void*)TrimCommandPool},
+    {"vkGetDeviceQueue2", (void*)GetDeviceQueue2},
+    {"vkGetPhysicalDeviceExternalBufferProperties", (void*)GetPhysicalDeviceExternalBufferProperties},
+    {"vkGetPhysicalDeviceExternalFenceProperties", (void*)GetPhysicalDeviceExternalFenceProperties},
+    {"vkGetPhysicalDeviceExternalSemaphoreProperties", (void*)GetPhysicalDeviceExternalSemaphoreProperties},
+    {"vkCmdDispatchBase", (void*)CmdDispatchBase},
+    {"vkCreateDescriptorUpdateTemplate", (void*)CreateDescriptorUpdateTemplate},
+    {"vkDestroyDescriptorUpdateTemplate", (void*)DestroyDescriptorUpdateTemplate},
+    {"vkUpdateDescriptorSetWithTemplate", (void*)UpdateDescriptorSetWithTemplate},
+    {"vkGetDescriptorSetLayoutSupport", (void*)GetDescriptorSetLayoutSupport},
+    {"vkCreateSamplerYcbcrConversion", (void*)CreateSamplerYcbcrConversion},
+    {"vkDestroySamplerYcbcrConversion", (void*)DestroySamplerYcbcrConversion},
+    {"vkResetQueryPool", (void*)ResetQueryPool},
+    {"vkGetSemaphoreCounterValue", (void*)GetSemaphoreCounterValue},
+    {"vkWaitSemaphores", (void*)WaitSemaphores},
+    {"vkSignalSemaphore", (void*)SignalSemaphore},
+    {"vkGetBufferDeviceAddress", (void*)GetBufferDeviceAddress},
+    {"vkGetBufferOpaqueCaptureAddress", (void*)GetBufferOpaqueCaptureAddress},
+    {"vkGetDeviceMemoryOpaqueCaptureAddress", (void*)GetDeviceMemoryOpaqueCaptureAddress},
+    {"vkCmdDrawIndirectCount", (void*)CmdDrawIndirectCount},
+    {"vkCmdDrawIndexedIndirectCount", (void*)CmdDrawIndexedIndirectCount},
+    {"vkCreateRenderPass2", (void*)CreateRenderPass2},
+    {"vkCmdBeginRenderPass2", (void*)CmdBeginRenderPass2},
+    {"vkCmdNextSubpass2", (void*)CmdNextSubpass2},
+    {"vkCmdEndRenderPass2", (void*)CmdEndRenderPass2},
+    {"vkGetPhysicalDeviceToolProperties", (void*)GetPhysicalDeviceToolProperties},
+    {"vkCreatePrivateDataSlot", (void*)CreatePrivateDataSlot},
+    {"vkDestroyPrivateDataSlot", (void*)DestroyPrivateDataSlot},
+    {"vkSetPrivateData", (void*)SetPrivateData},
+    {"vkGetPrivateData", (void*)GetPrivateData},
+    {"vkCmdPipelineBarrier2", (void*)CmdPipelineBarrier2},
+    {"vkCmdWriteTimestamp2", (void*)CmdWriteTimestamp2},
+    {"vkQueueSubmit2", (void*)QueueSubmit2},
+    {"vkCmdCopyBuffer2", (void*)CmdCopyBuffer2},
+    {"vkCmdCopyImage2", (void*)CmdCopyImage2},
+    {"vkCmdCopyBufferToImage2", (void*)CmdCopyBufferToImage2},
+    {"vkCmdCopyImageToBuffer2", (void*)CmdCopyImageToBuffer2},
+    {"vkGetDeviceBufferMemoryRequirements", (void*)GetDeviceBufferMemoryRequirements},
+    {"vkGetDeviceImageMemoryRequirements", (void*)GetDeviceImageMemoryRequirements},
+    {"vkGetDeviceImageSparseMemoryRequirements", (void*)GetDeviceImageSparseMemoryRequirements},
+    {"vkCmdSetEvent2", (void*)CmdSetEvent2},
+    {"vkCmdResetEvent2", (void*)CmdResetEvent2},
+    {"vkCmdWaitEvents2", (void*)CmdWaitEvents2},
+    {"vkCmdBlitImage2", (void*)CmdBlitImage2},
+    {"vkCmdResolveImage2", (void*)CmdResolveImage2},
+    {"vkCmdBeginRendering", (void*)CmdBeginRendering},
+    {"vkCmdEndRendering", (void*)CmdEndRendering},
+    {"vkCmdSetCullMode", (void*)CmdSetCullMode},
+    {"vkCmdSetFrontFace", (void*)CmdSetFrontFace},
+    {"vkCmdSetPrimitiveTopology", (void*)CmdSetPrimitiveTopology},
+    {"vkCmdSetViewportWithCount", (void*)CmdSetViewportWithCount},
+    {"vkCmdSetScissorWithCount", (void*)CmdSetScissorWithCount},
+    {"vkCmdBindVertexBuffers2", (void*)CmdBindVertexBuffers2},
+    {"vkCmdSetDepthTestEnable", (void*)CmdSetDepthTestEnable},
+    {"vkCmdSetDepthWriteEnable", (void*)CmdSetDepthWriteEnable},
+    {"vkCmdSetDepthCompareOp", (void*)CmdSetDepthCompareOp},
+    {"vkCmdSetDepthBoundsTestEnable", (void*)CmdSetDepthBoundsTestEnable},
+    {"vkCmdSetStencilTestEnable", (void*)CmdSetStencilTestEnable},
+    {"vkCmdSetStencilOp", (void*)CmdSetStencilOp},
+    {"vkCmdSetRasterizerDiscardEnable", (void*)CmdSetRasterizerDiscardEnable},
+    {"vkCmdSetDepthBiasEnable", (void*)CmdSetDepthBiasEnable},
+    {"vkCmdSetPrimitiveRestartEnable", (void*)CmdSetPrimitiveRestartEnable},
+    {"vkMapMemory2", (void*)MapMemory2},
+    {"vkUnmapMemory2", (void*)UnmapMemory2},
+    {"vkGetDeviceImageSubresourceLayout", (void*)GetDeviceImageSubresourceLayout},
+    {"vkGetImageSubresourceLayout2", (void*)GetImageSubresourceLayout2},
+    {"vkCopyMemoryToImage", (void*)CopyMemoryToImage},
+    {"vkCopyImageToMemory", (void*)CopyImageToMemory},
+    {"vkCopyImageToImage", (void*)CopyImageToImage},
+    {"vkTransitionImageLayout", (void*)TransitionImageLayout},
+    {"vkCmdPushDescriptorSet", (void*)CmdPushDescriptorSet},
+    {"vkCmdPushDescriptorSetWithTemplate", (void*)CmdPushDescriptorSetWithTemplate},
+    {"vkCmdBindDescriptorSets2", (void*)CmdBindDescriptorSets2},
+    {"vkCmdPushConstants2", (void*)CmdPushConstants2},
+    {"vkCmdPushDescriptorSet2", (void*)CmdPushDescriptorSet2},
+    {"vkCmdPushDescriptorSetWithTemplate2", (void*)CmdPushDescriptorSetWithTemplate2},
+    {"vkCmdSetLineStipple", (void*)CmdSetLineStipple},
+    {"vkCmdBindIndexBuffer2", (void*)CmdBindIndexBuffer2},
+    {"vkGetRenderingAreaGranularity", (void*)GetRenderingAreaGranularity},
+    {"vkCmdSetRenderingAttachmentLocations", (void*)CmdSetRenderingAttachmentLocations},
+    {"vkCmdSetRenderingInputAttachmentIndices", (void*)CmdSetRenderingInputAttachmentIndices},
+    {"vkDestroySurfaceKHR", (void*)DestroySurfaceKHR},
+    {"vkGetPhysicalDeviceSurfaceSupportKHR", (void*)GetPhysicalDeviceSurfaceSupportKHR},
+    {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", (void*)GetPhysicalDeviceSurfaceCapabilitiesKHR},
+    {"vkGetPhysicalDeviceSurfaceFormatsKHR", (void*)GetPhysicalDeviceSurfaceFormatsKHR},
+    {"vkGetPhysicalDeviceSurfacePresentModesKHR", (void*)GetPhysicalDeviceSurfacePresentModesKHR},
+    {"vkCreateSwapchainKHR", (void*)CreateSwapchainKHR},
+    {"vkDestroySwapchainKHR", (void*)DestroySwapchainKHR},
+    {"vkGetSwapchainImagesKHR", (void*)GetSwapchainImagesKHR},
+    {"vkAcquireNextImageKHR", (void*)AcquireNextImageKHR},
+    {"vkQueuePresentKHR", (void*)QueuePresentKHR},
+    {"vkGetDeviceGroupPresentCapabilitiesKHR", (void*)GetDeviceGroupPresentCapabilitiesKHR},
+    {"vkGetDeviceGroupSurfacePresentModesKHR", (void*)GetDeviceGroupSurfacePresentModesKHR},
+    {"vkGetPhysicalDevicePresentRectanglesKHR", (void*)GetPhysicalDevicePresentRectanglesKHR},
+    {"vkAcquireNextImage2KHR", (void*)AcquireNextImage2KHR},
+    {"vkGetPhysicalDeviceDisplayPropertiesKHR", (void*)GetPhysicalDeviceDisplayPropertiesKHR},
+    {"vkGetPhysicalDeviceDisplayPlanePropertiesKHR", (void*)GetPhysicalDeviceDisplayPlanePropertiesKHR},
+    {"vkGetDisplayPlaneSupportedDisplaysKHR", (void*)GetDisplayPlaneSupportedDisplaysKHR},
+    {"vkGetDisplayModePropertiesKHR", (void*)GetDisplayModePropertiesKHR},
+    {"vkCreateDisplayModeKHR", (void*)CreateDisplayModeKHR},
+    {"vkGetDisplayPlaneCapabilitiesKHR", (void*)GetDisplayPlaneCapabilitiesKHR},
+    {"vkCreateDisplayPlaneSurfaceKHR", (void*)CreateDisplayPlaneSurfaceKHR},
+    {"vkCreateSharedSwapchainsKHR", (void*)CreateSharedSwapchainsKHR},
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+    {"vkCreateXlibSurfaceKHR", (void*)CreateXlibSurfaceKHR},
+#endif
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+    {"vkGetPhysicalDeviceXlibPresentationSupportKHR", (void*)GetPhysicalDeviceXlibPresentationSupportKHR},
+#endif
+#ifdef VK_USE_PLATFORM_XCB_KHR
+    {"vkCreateXcbSurfaceKHR", (void*)CreateXcbSurfaceKHR},
+#endif
+#ifdef VK_USE_PLATFORM_XCB_KHR
+    {"vkGetPhysicalDeviceXcbPresentationSupportKHR", (void*)GetPhysicalDeviceXcbPresentationSupportKHR},
+#endif
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+    {"vkCreateWaylandSurfaceKHR", (void*)CreateWaylandSurfaceKHR},
+#endif
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+    {"vkGetPhysicalDeviceWaylandPresentationSupportKHR", (void*)GetPhysicalDeviceWaylandPresentationSupportKHR},
+#endif
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+    {"vkCreateAndroidSurfaceKHR", (void*)CreateAndroidSurfaceKHR},
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    {"vkCreateWin32SurfaceKHR", (void*)CreateWin32SurfaceKHR},
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    {"vkGetPhysicalDeviceWin32PresentationSupportKHR", (void*)GetPhysicalDeviceWin32PresentationSupportKHR},
+#endif
+    {"vkGetPhysicalDeviceVideoCapabilitiesKHR", (void*)GetPhysicalDeviceVideoCapabilitiesKHR},
+    {"vkGetPhysicalDeviceVideoFormatPropertiesKHR", (void*)GetPhysicalDeviceVideoFormatPropertiesKHR},
+    {"vkCreateVideoSessionKHR", (void*)CreateVideoSessionKHR},
+    {"vkDestroyVideoSessionKHR", (void*)DestroyVideoSessionKHR},
+    {"vkGetVideoSessionMemoryRequirementsKHR", (void*)GetVideoSessionMemoryRequirementsKHR},
+    {"vkBindVideoSessionMemoryKHR", (void*)BindVideoSessionMemoryKHR},
+    {"vkCreateVideoSessionParametersKHR", (void*)CreateVideoSessionParametersKHR},
+    {"vkUpdateVideoSessionParametersKHR", (void*)UpdateVideoSessionParametersKHR},
+    {"vkDestroyVideoSessionParametersKHR", (void*)DestroyVideoSessionParametersKHR},
+    {"vkCmdBeginVideoCodingKHR", (void*)CmdBeginVideoCodingKHR},
+    {"vkCmdEndVideoCodingKHR", (void*)CmdEndVideoCodingKHR},
+    {"vkCmdControlVideoCodingKHR", (void*)CmdControlVideoCodingKHR},
+    {"vkCmdDecodeVideoKHR", (void*)CmdDecodeVideoKHR},
+    {"vkCmdBeginRenderingKHR", (void*)CmdBeginRenderingKHR},
+    {"vkCmdEndRenderingKHR", (void*)CmdEndRenderingKHR},
+    {"vkGetPhysicalDeviceFeatures2KHR", (void*)GetPhysicalDeviceFeatures2KHR},
+    {"vkGetPhysicalDeviceProperties2KHR", (void*)GetPhysicalDeviceProperties2KHR},
+    {"vkGetPhysicalDeviceFormatProperties2KHR", (void*)GetPhysicalDeviceFormatProperties2KHR},
+    {"vkGetPhysicalDeviceImageFormatProperties2KHR", (void*)GetPhysicalDeviceImageFormatProperties2KHR},
+    {"vkGetPhysicalDeviceQueueFamilyProperties2KHR", (void*)GetPhysicalDeviceQueueFamilyProperties2KHR},
+    {"vkGetPhysicalDeviceMemoryProperties2KHR", (void*)GetPhysicalDeviceMemoryProperties2KHR},
+    {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", (void*)GetPhysicalDeviceSparseImageFormatProperties2KHR},
+    {"vkGetDeviceGroupPeerMemoryFeaturesKHR", (void*)GetDeviceGroupPeerMemoryFeaturesKHR},
+    {"vkCmdSetDeviceMaskKHR", (void*)CmdSetDeviceMaskKHR},
+    {"vkCmdDispatchBaseKHR", (void*)CmdDispatchBaseKHR},
+    {"vkTrimCommandPoolKHR", (void*)TrimCommandPoolKHR},
+    {"vkEnumeratePhysicalDeviceGroupsKHR", (void*)EnumeratePhysicalDeviceGroupsKHR},
+    {"vkGetPhysicalDeviceExternalBufferPropertiesKHR", (void*)GetPhysicalDeviceExternalBufferPropertiesKHR},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    {"vkGetMemoryWin32HandleKHR", (void*)GetMemoryWin32HandleKHR},
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    {"vkGetMemoryWin32HandlePropertiesKHR", (void*)GetMemoryWin32HandlePropertiesKHR},
+#endif
+    {"vkGetMemoryFdKHR", (void*)GetMemoryFdKHR},
+    {"vkGetMemoryFdPropertiesKHR", (void*)GetMemoryFdPropertiesKHR},
+    {"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", (void*)GetPhysicalDeviceExternalSemaphorePropertiesKHR},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    {"vkImportSemaphoreWin32HandleKHR", (void*)ImportSemaphoreWin32HandleKHR},
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    {"vkGetSemaphoreWin32HandleKHR", (void*)GetSemaphoreWin32HandleKHR},
+#endif
+    {"vkImportSemaphoreFdKHR", (void*)ImportSemaphoreFdKHR},
+    {"vkGetSemaphoreFdKHR", (void*)GetSemaphoreFdKHR},
+    {"vkCmdPushDescriptorSetKHR", (void*)CmdPushDescriptorSetKHR},
+    {"vkCmdPushDescriptorSetWithTemplateKHR", (void*)CmdPushDescriptorSetWithTemplateKHR},
+    {"vkCreateDescriptorUpdateTemplateKHR", (void*)CreateDescriptorUpdateTemplateKHR},
+    {"vkDestroyDescriptorUpdateTemplateKHR", (void*)DestroyDescriptorUpdateTemplateKHR},
+    {"vkUpdateDescriptorSetWithTemplateKHR", (void*)UpdateDescriptorSetWithTemplateKHR},
+    {"vkCreateRenderPass2KHR", (void*)CreateRenderPass2KHR},
+    {"vkCmdBeginRenderPass2KHR", (void*)CmdBeginRenderPass2KHR},
+    {"vkCmdNextSubpass2KHR", (void*)CmdNextSubpass2KHR},
+    {"vkCmdEndRenderPass2KHR", (void*)CmdEndRenderPass2KHR},
+    {"vkGetSwapchainStatusKHR", (void*)GetSwapchainStatusKHR},
+    {"vkGetPhysicalDeviceExternalFencePropertiesKHR", (void*)GetPhysicalDeviceExternalFencePropertiesKHR},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    {"vkImportFenceWin32HandleKHR", (void*)ImportFenceWin32HandleKHR},
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    {"vkGetFenceWin32HandleKHR", (void*)GetFenceWin32HandleKHR},
+#endif
+    {"vkImportFenceFdKHR", (void*)ImportFenceFdKHR},
+    {"vkGetFenceFdKHR", (void*)GetFenceFdKHR},
+    {"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR",
+     (void*)EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR},
+    {"vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR", (void*)GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR},
+    {"vkAcquireProfilingLockKHR", (void*)AcquireProfilingLockKHR},
+    {"vkReleaseProfilingLockKHR", (void*)ReleaseProfilingLockKHR},
+    {"vkGetPhysicalDeviceSurfaceCapabilities2KHR", (void*)GetPhysicalDeviceSurfaceCapabilities2KHR},
+    {"vkGetPhysicalDeviceSurfaceFormats2KHR", (void*)GetPhysicalDeviceSurfaceFormats2KHR},
+    {"vkGetPhysicalDeviceDisplayProperties2KHR", (void*)GetPhysicalDeviceDisplayProperties2KHR},
+    {"vkGetPhysicalDeviceDisplayPlaneProperties2KHR", (void*)GetPhysicalDeviceDisplayPlaneProperties2KHR},
+    {"vkGetDisplayModeProperties2KHR", (void*)GetDisplayModeProperties2KHR},
+    {"vkGetDisplayPlaneCapabilities2KHR", (void*)GetDisplayPlaneCapabilities2KHR},
+    {"vkGetImageMemoryRequirements2KHR", (void*)GetImageMemoryRequirements2KHR},
+    {"vkGetBufferMemoryRequirements2KHR", (void*)GetBufferMemoryRequirements2KHR},
+    {"vkGetImageSparseMemoryRequirements2KHR", (void*)GetImageSparseMemoryRequirements2KHR},
+    {"vkCreateSamplerYcbcrConversionKHR", (void*)CreateSamplerYcbcrConversionKHR},
+    {"vkDestroySamplerYcbcrConversionKHR", (void*)DestroySamplerYcbcrConversionKHR},
+    {"vkBindBufferMemory2KHR", (void*)BindBufferMemory2KHR},
+    {"vkBindImageMemory2KHR", (void*)BindImageMemory2KHR},
+    {"vkGetDescriptorSetLayoutSupportKHR", (void*)GetDescriptorSetLayoutSupportKHR},
+    {"vkCmdDrawIndirectCountKHR", (void*)CmdDrawIndirectCountKHR},
+    {"vkCmdDrawIndexedIndirectCountKHR", (void*)CmdDrawIndexedIndirectCountKHR},
+    {"vkGetSemaphoreCounterValueKHR", (void*)GetSemaphoreCounterValueKHR},
+    {"vkWaitSemaphoresKHR", (void*)WaitSemaphoresKHR},
+    {"vkSignalSemaphoreKHR", (void*)SignalSemaphoreKHR},
+    {"vkGetPhysicalDeviceFragmentShadingRatesKHR", (void*)GetPhysicalDeviceFragmentShadingRatesKHR},
+    {"vkCmdSetFragmentShadingRateKHR", (void*)CmdSetFragmentShadingRateKHR},
+    {"vkCmdSetRenderingAttachmentLocationsKHR", (void*)CmdSetRenderingAttachmentLocationsKHR},
+    {"vkCmdSetRenderingInputAttachmentIndicesKHR", (void*)CmdSetRenderingInputAttachmentIndicesKHR},
+    {"vkWaitForPresentKHR", (void*)WaitForPresentKHR},
+    {"vkGetBufferDeviceAddressKHR", (void*)GetBufferDeviceAddressKHR},
+    {"vkGetBufferOpaqueCaptureAddressKHR", (void*)GetBufferOpaqueCaptureAddressKHR},
+    {"vkGetDeviceMemoryOpaqueCaptureAddressKHR", (void*)GetDeviceMemoryOpaqueCaptureAddressKHR},
+    {"vkCreateDeferredOperationKHR", (void*)CreateDeferredOperationKHR},
+    {"vkDestroyDeferredOperationKHR", (void*)DestroyDeferredOperationKHR},
+    {"vkGetDeferredOperationMaxConcurrencyKHR", (void*)GetDeferredOperationMaxConcurrencyKHR},
+    {"vkGetDeferredOperationResultKHR", (void*)GetDeferredOperationResultKHR},
+    {"vkDeferredOperationJoinKHR", (void*)DeferredOperationJoinKHR},
+    {"vkGetPipelineExecutablePropertiesKHR", (void*)GetPipelineExecutablePropertiesKHR},
+    {"vkGetPipelineExecutableStatisticsKHR", (void*)GetPipelineExecutableStatisticsKHR},
+    {"vkGetPipelineExecutableInternalRepresentationsKHR", (void*)GetPipelineExecutableInternalRepresentationsKHR},
+    {"vkMapMemory2KHR", (void*)MapMemory2KHR},
+    {"vkUnmapMemory2KHR", (void*)UnmapMemory2KHR},
+    {"vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR", (void*)GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR},
+    {"vkGetEncodedVideoSessionParametersKHR", (void*)GetEncodedVideoSessionParametersKHR},
+    {"vkCmdEncodeVideoKHR", (void*)CmdEncodeVideoKHR},
+    {"vkCmdSetEvent2KHR", (void*)CmdSetEvent2KHR},
+    {"vkCmdResetEvent2KHR", (void*)CmdResetEvent2KHR},
+    {"vkCmdWaitEvents2KHR", (void*)CmdWaitEvents2KHR},
+    {"vkCmdPipelineBarrier2KHR", (void*)CmdPipelineBarrier2KHR},
+    {"vkCmdWriteTimestamp2KHR", (void*)CmdWriteTimestamp2KHR},
+    {"vkQueueSubmit2KHR", (void*)QueueSubmit2KHR},
+    {"vkCmdBindIndexBuffer3KHR", (void*)CmdBindIndexBuffer3KHR},
+    {"vkCmdBindVertexBuffers3KHR", (void*)CmdBindVertexBuffers3KHR},
+    {"vkCmdDrawIndirect2KHR", (void*)CmdDrawIndirect2KHR},
+    {"vkCmdDrawIndexedIndirect2KHR", (void*)CmdDrawIndexedIndirect2KHR},
+    {"vkCmdDispatchIndirect2KHR", (void*)CmdDispatchIndirect2KHR},
+    {"vkCmdCopyMemoryKHR", (void*)CmdCopyMemoryKHR},
+    {"vkCmdCopyMemoryToImageKHR", (void*)CmdCopyMemoryToImageKHR},
+    {"vkCmdCopyImageToMemoryKHR", (void*)CmdCopyImageToMemoryKHR},
+    {"vkCmdUpdateMemoryKHR", (void*)CmdUpdateMemoryKHR},
+    {"vkCmdFillMemoryKHR", (void*)CmdFillMemoryKHR},
+    {"vkCmdCopyQueryPoolResultsToMemoryKHR", (void*)CmdCopyQueryPoolResultsToMemoryKHR},
+    {"vkCmdDrawIndirectCount2KHR", (void*)CmdDrawIndirectCount2KHR},
+    {"vkCmdDrawIndexedIndirectCount2KHR", (void*)CmdDrawIndexedIndirectCount2KHR},
+    {"vkCmdBeginConditionalRendering2EXT", (void*)CmdBeginConditionalRendering2EXT},
+    {"vkCmdBindTransformFeedbackBuffers2EXT", (void*)CmdBindTransformFeedbackBuffers2EXT},
+    {"vkCmdBeginTransformFeedback2EXT", (void*)CmdBeginTransformFeedback2EXT},
+    {"vkCmdEndTransformFeedback2EXT", (void*)CmdEndTransformFeedback2EXT},
+    {"vkCmdDrawIndirectByteCount2EXT", (void*)CmdDrawIndirectByteCount2EXT},
+    {"vkCmdDrawMeshTasksIndirect2EXT", (void*)CmdDrawMeshTasksIndirect2EXT},
+    {"vkCmdDrawMeshTasksIndirectCount2EXT", (void*)CmdDrawMeshTasksIndirectCount2EXT},
+    {"vkCmdWriteMarkerToMemoryAMD", (void*)CmdWriteMarkerToMemoryAMD},
+    {"vkCreateAccelerationStructure2KHR", (void*)CreateAccelerationStructure2KHR},
+    {"vkCmdCopyBuffer2KHR", (void*)CmdCopyBuffer2KHR},
+    {"vkCmdCopyImage2KHR", (void*)CmdCopyImage2KHR},
+    {"vkCmdCopyBufferToImage2KHR", (void*)CmdCopyBufferToImage2KHR},
+    {"vkCmdCopyImageToBuffer2KHR", (void*)CmdCopyImageToBuffer2KHR},
+    {"vkCmdBlitImage2KHR", (void*)CmdBlitImage2KHR},
+    {"vkCmdResolveImage2KHR", (void*)CmdResolveImage2KHR},
+    {"vkCmdTraceRaysIndirect2KHR", (void*)CmdTraceRaysIndirect2KHR},
+    {"vkGetDeviceBufferMemoryRequirementsKHR", (void*)GetDeviceBufferMemoryRequirementsKHR},
+    {"vkGetDeviceImageMemoryRequirementsKHR", (void*)GetDeviceImageMemoryRequirementsKHR},
+    {"vkGetDeviceImageSparseMemoryRequirementsKHR", (void*)GetDeviceImageSparseMemoryRequirementsKHR},
+    {"vkCmdBindIndexBuffer2KHR", (void*)CmdBindIndexBuffer2KHR},
+    {"vkGetRenderingAreaGranularityKHR", (void*)GetRenderingAreaGranularityKHR},
+    {"vkGetDeviceImageSubresourceLayoutKHR", (void*)GetDeviceImageSubresourceLayoutKHR},
+    {"vkGetImageSubresourceLayout2KHR", (void*)GetImageSubresourceLayout2KHR},
+    {"vkWaitForPresent2KHR", (void*)WaitForPresent2KHR},
+    {"vkCreatePipelineBinariesKHR", (void*)CreatePipelineBinariesKHR},
+    {"vkDestroyPipelineBinaryKHR", (void*)DestroyPipelineBinaryKHR},
+    {"vkGetPipelineKeyKHR", (void*)GetPipelineKeyKHR},
+    {"vkGetPipelineBinaryDataKHR", (void*)GetPipelineBinaryDataKHR},
+    {"vkReleaseCapturedPipelineDataKHR", (void*)ReleaseCapturedPipelineDataKHR},
+    {"vkReleaseSwapchainImagesKHR", (void*)ReleaseSwapchainImagesKHR},
+    {"vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR", (void*)GetPhysicalDeviceCooperativeMatrixPropertiesKHR},
+    {"vkCmdSetLineStippleKHR", (void*)CmdSetLineStippleKHR},
+    {"vkGetPhysicalDeviceCalibrateableTimeDomainsKHR", (void*)GetPhysicalDeviceCalibrateableTimeDomainsKHR},
+    {"vkGetCalibratedTimestampsKHR", (void*)GetCalibratedTimestampsKHR},
+    {"vkCmdBindDescriptorSets2KHR", (void*)CmdBindDescriptorSets2KHR},
+    {"vkCmdPushConstants2KHR", (void*)CmdPushConstants2KHR},
+    {"vkCmdPushDescriptorSet2KHR", (void*)CmdPushDescriptorSet2KHR},
+    {"vkCmdPushDescriptorSetWithTemplate2KHR", (void*)CmdPushDescriptorSetWithTemplate2KHR},
+    {"vkCmdSetDescriptorBufferOffsets2EXT", (void*)CmdSetDescriptorBufferOffsets2EXT},
+    {"vkCmdBindDescriptorBufferEmbeddedSamplers2EXT", (void*)CmdBindDescriptorBufferEmbeddedSamplers2EXT},
+    {"vkCmdCopyMemoryIndirectKHR", (void*)CmdCopyMemoryIndirectKHR},
+    {"vkCmdCopyMemoryToImageIndirectKHR", (void*)CmdCopyMemoryToImageIndirectKHR},
+    {"vkGetDeviceFaultReportsKHR", (void*)GetDeviceFaultReportsKHR},
+    {"vkGetDeviceFaultDebugInfoKHR", (void*)GetDeviceFaultDebugInfoKHR},
+    {"vkCmdEndRendering2KHR", (void*)CmdEndRendering2KHR},
+    {"vkCreateDebugReportCallbackEXT", (void*)CreateDebugReportCallbackEXT},
+    {"vkDestroyDebugReportCallbackEXT", (void*)DestroyDebugReportCallbackEXT},
+    {"vkDebugReportMessageEXT", (void*)DebugReportMessageEXT},
+    {"vkDebugMarkerSetObjectTagEXT", (void*)DebugMarkerSetObjectTagEXT},
+    {"vkDebugMarkerSetObjectNameEXT", (void*)DebugMarkerSetObjectNameEXT},
+    {"vkCmdDebugMarkerBeginEXT", (void*)CmdDebugMarkerBeginEXT},
+    {"vkCmdDebugMarkerEndEXT", (void*)CmdDebugMarkerEndEXT},
+    {"vkCmdDebugMarkerInsertEXT", (void*)CmdDebugMarkerInsertEXT},
+    {"vkCmdBindTransformFeedbackBuffersEXT", (void*)CmdBindTransformFeedbackBuffersEXT},
+    {"vkCmdBeginTransformFeedbackEXT", (void*)CmdBeginTransformFeedbackEXT},
+    {"vkCmdEndTransformFeedbackEXT", (void*)CmdEndTransformFeedbackEXT},
+    {"vkCmdBeginQueryIndexedEXT", (void*)CmdBeginQueryIndexedEXT},
+    {"vkCmdEndQueryIndexedEXT", (void*)CmdEndQueryIndexedEXT},
+    {"vkCmdDrawIndirectByteCountEXT", (void*)CmdDrawIndirectByteCountEXT},
+    {"vkCreateCuModuleNVX", (void*)CreateCuModuleNVX},
+    {"vkCreateCuFunctionNVX", (void*)CreateCuFunctionNVX},
+    {"vkDestroyCuModuleNVX", (void*)DestroyCuModuleNVX},
+    {"vkDestroyCuFunctionNVX", (void*)DestroyCuFunctionNVX},
+    {"vkCmdCuLaunchKernelNVX", (void*)CmdCuLaunchKernelNVX},
+    {"vkGetImageViewHandleNVX", (void*)GetImageViewHandleNVX},
+    {"vkGetImageViewHandle64NVX", (void*)GetImageViewHandle64NVX},
+    {"vkGetImageViewAddressNVX", (void*)GetImageViewAddressNVX},
+    {"vkGetDeviceCombinedImageSamplerIndexNVX", (void*)GetDeviceCombinedImageSamplerIndexNVX},
+    {"vkCmdDrawIndirectCountAMD", (void*)CmdDrawIndirectCountAMD},
+    {"vkCmdDrawIndexedIndirectCountAMD", (void*)CmdDrawIndexedIndirectCountAMD},
+    {"vkGetShaderInfoAMD", (void*)GetShaderInfoAMD},
+#ifdef VK_USE_PLATFORM_GGP
+    {"vkCreateStreamDescriptorSurfaceGGP", (void*)CreateStreamDescriptorSurfaceGGP},
+#endif
+    {"vkGetPhysicalDeviceExternalImageFormatPropertiesNV", (void*)GetPhysicalDeviceExternalImageFormatPropertiesNV},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    {"vkGetMemoryWin32HandleNV", (void*)GetMemoryWin32HandleNV},
+#endif
+#ifdef VK_USE_PLATFORM_VI_NN
+    {"vkCreateViSurfaceNN", (void*)CreateViSurfaceNN},
+#endif
+    {"vkCmdBeginConditionalRenderingEXT", (void*)CmdBeginConditionalRenderingEXT},
+    {"vkCmdEndConditionalRenderingEXT", (void*)CmdEndConditionalRenderingEXT},
+    {"vkCmdSetViewportWScalingNV", (void*)CmdSetViewportWScalingNV},
+    {"vkReleaseDisplayEXT", (void*)ReleaseDisplayEXT},
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+    {"vkAcquireXlibDisplayEXT", (void*)AcquireXlibDisplayEXT},
+#endif
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+    {"vkGetRandROutputDisplayEXT", (void*)GetRandROutputDisplayEXT},
+#endif
+    {"vkGetPhysicalDeviceSurfaceCapabilities2EXT", (void*)GetPhysicalDeviceSurfaceCapabilities2EXT},
+    {"vkDisplayPowerControlEXT", (void*)DisplayPowerControlEXT},
+    {"vkRegisterDeviceEventEXT", (void*)RegisterDeviceEventEXT},
+    {"vkRegisterDisplayEventEXT", (void*)RegisterDisplayEventEXT},
+    {"vkGetSwapchainCounterEXT", (void*)GetSwapchainCounterEXT},
+    {"vkGetRefreshCycleDurationGOOGLE", (void*)GetRefreshCycleDurationGOOGLE},
+    {"vkGetPastPresentationTimingGOOGLE", (void*)GetPastPresentationTimingGOOGLE},
+    {"vkCmdSetDiscardRectangleEXT", (void*)CmdSetDiscardRectangleEXT},
+    {"vkCmdSetDiscardRectangleEnableEXT", (void*)CmdSetDiscardRectangleEnableEXT},
+    {"vkCmdSetDiscardRectangleModeEXT", (void*)CmdSetDiscardRectangleModeEXT},
+    {"vkSetHdrMetadataEXT", (void*)SetHdrMetadataEXT},
+#ifdef VK_USE_PLATFORM_IOS_MVK
+    {"vkCreateIOSSurfaceMVK", (void*)CreateIOSSurfaceMVK},
+#endif
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+    {"vkCreateMacOSSurfaceMVK", (void*)CreateMacOSSurfaceMVK},
+#endif
+    {"vkSetDebugUtilsObjectNameEXT", (void*)SetDebugUtilsObjectNameEXT},
+    {"vkSetDebugUtilsObjectTagEXT", (void*)SetDebugUtilsObjectTagEXT},
+    {"vkQueueBeginDebugUtilsLabelEXT", (void*)QueueBeginDebugUtilsLabelEXT},
+    {"vkQueueEndDebugUtilsLabelEXT", (void*)QueueEndDebugUtilsLabelEXT},
+    {"vkQueueInsertDebugUtilsLabelEXT", (void*)QueueInsertDebugUtilsLabelEXT},
+    {"vkCmdBeginDebugUtilsLabelEXT", (void*)CmdBeginDebugUtilsLabelEXT},
+    {"vkCmdEndDebugUtilsLabelEXT", (void*)CmdEndDebugUtilsLabelEXT},
+    {"vkCmdInsertDebugUtilsLabelEXT", (void*)CmdInsertDebugUtilsLabelEXT},
+    {"vkCreateDebugUtilsMessengerEXT", (void*)CreateDebugUtilsMessengerEXT},
+    {"vkDestroyDebugUtilsMessengerEXT", (void*)DestroyDebugUtilsMessengerEXT},
+    {"vkSubmitDebugUtilsMessageEXT", (void*)SubmitDebugUtilsMessageEXT},
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+    {"vkGetAndroidHardwareBufferPropertiesANDROID", (void*)GetAndroidHardwareBufferPropertiesANDROID},
+#endif
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+    {"vkGetMemoryAndroidHardwareBufferANDROID", (void*)GetMemoryAndroidHardwareBufferANDROID},
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    {"vkCreateExecutionGraphPipelinesAMDX", (void*)CreateExecutionGraphPipelinesAMDX},
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    {"vkGetExecutionGraphPipelineScratchSizeAMDX", (void*)GetExecutionGraphPipelineScratchSizeAMDX},
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    {"vkGetExecutionGraphPipelineNodeIndexAMDX", (void*)GetExecutionGraphPipelineNodeIndexAMDX},
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    {"vkCmdInitializeGraphScratchMemoryAMDX", (void*)CmdInitializeGraphScratchMemoryAMDX},
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    {"vkCmdDispatchGraphAMDX", (void*)CmdDispatchGraphAMDX},
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    {"vkCmdDispatchGraphIndirectAMDX", (void*)CmdDispatchGraphIndirectAMDX},
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    {"vkCmdDispatchGraphIndirectCountAMDX", (void*)CmdDispatchGraphIndirectCountAMDX},
+#endif
+    {"vkWriteSamplerDescriptorsEXT", (void*)WriteSamplerDescriptorsEXT},
+    {"vkWriteResourceDescriptorsEXT", (void*)WriteResourceDescriptorsEXT},
+    {"vkCmdBindSamplerHeapEXT", (void*)CmdBindSamplerHeapEXT},
+    {"vkCmdBindResourceHeapEXT", (void*)CmdBindResourceHeapEXT},
+    {"vkCmdPushDataEXT", (void*)CmdPushDataEXT},
+    {"vkGetImageOpaqueCaptureDataEXT", (void*)GetImageOpaqueCaptureDataEXT},
+    {"vkGetPhysicalDeviceDescriptorSizeEXT", (void*)GetPhysicalDeviceDescriptorSizeEXT},
+    {"vkRegisterCustomBorderColorEXT", (void*)RegisterCustomBorderColorEXT},
+    {"vkUnregisterCustomBorderColorEXT", (void*)UnregisterCustomBorderColorEXT},
+    {"vkGetTensorOpaqueCaptureDataARM", (void*)GetTensorOpaqueCaptureDataARM},
+    {"vkCmdSetSampleLocationsEXT", (void*)CmdSetSampleLocationsEXT},
+    {"vkGetPhysicalDeviceMultisamplePropertiesEXT", (void*)GetPhysicalDeviceMultisamplePropertiesEXT},
+    {"vkGetImageDrmFormatModifierPropertiesEXT", (void*)GetImageDrmFormatModifierPropertiesEXT},
+    {"vkCreateValidationCacheEXT", (void*)CreateValidationCacheEXT},
+    {"vkDestroyValidationCacheEXT", (void*)DestroyValidationCacheEXT},
+    {"vkMergeValidationCachesEXT", (void*)MergeValidationCachesEXT},
+    {"vkGetValidationCacheDataEXT", (void*)GetValidationCacheDataEXT},
+    {"vkCmdBindShadingRateImageNV", (void*)CmdBindShadingRateImageNV},
+    {"vkCmdSetViewportShadingRatePaletteNV", (void*)CmdSetViewportShadingRatePaletteNV},
+    {"vkCmdSetCoarseSampleOrderNV", (void*)CmdSetCoarseSampleOrderNV},
+    {"vkCreateAccelerationStructureNV", (void*)CreateAccelerationStructureNV},
+    {"vkDestroyAccelerationStructureNV", (void*)DestroyAccelerationStructureNV},
+    {"vkGetAccelerationStructureMemoryRequirementsNV", (void*)GetAccelerationStructureMemoryRequirementsNV},
+    {"vkBindAccelerationStructureMemoryNV", (void*)BindAccelerationStructureMemoryNV},
+    {"vkCmdBuildAccelerationStructureNV", (void*)CmdBuildAccelerationStructureNV},
+    {"vkCmdCopyAccelerationStructureNV", (void*)CmdCopyAccelerationStructureNV},
+    {"vkCmdTraceRaysNV", (void*)CmdTraceRaysNV},
+    {"vkCreateRayTracingPipelinesNV", (void*)CreateRayTracingPipelinesNV},
+    {"vkGetRayTracingShaderGroupHandlesKHR", (void*)GetRayTracingShaderGroupHandlesKHR},
+    {"vkGetRayTracingShaderGroupHandlesNV", (void*)GetRayTracingShaderGroupHandlesNV},
+    {"vkGetAccelerationStructureHandleNV", (void*)GetAccelerationStructureHandleNV},
+    {"vkCmdWriteAccelerationStructuresPropertiesNV", (void*)CmdWriteAccelerationStructuresPropertiesNV},
+    {"vkCompileDeferredNV", (void*)CompileDeferredNV},
+    {"vkGetMemoryHostPointerPropertiesEXT", (void*)GetMemoryHostPointerPropertiesEXT},
+    {"vkCmdWriteBufferMarkerAMD", (void*)CmdWriteBufferMarkerAMD},
+    {"vkCmdWriteBufferMarker2AMD", (void*)CmdWriteBufferMarker2AMD},
+    {"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", (void*)GetPhysicalDeviceCalibrateableTimeDomainsEXT},
+    {"vkGetCalibratedTimestampsEXT", (void*)GetCalibratedTimestampsEXT},
+    {"vkCmdDrawMeshTasksNV", (void*)CmdDrawMeshTasksNV},
+    {"vkCmdDrawMeshTasksIndirectNV", (void*)CmdDrawMeshTasksIndirectNV},
+    {"vkCmdDrawMeshTasksIndirectCountNV", (void*)CmdDrawMeshTasksIndirectCountNV},
+    {"vkCmdSetExclusiveScissorEnableNV", (void*)CmdSetExclusiveScissorEnableNV},
+    {"vkCmdSetExclusiveScissorNV", (void*)CmdSetExclusiveScissorNV},
+    {"vkCmdSetCheckpointNV", (void*)CmdSetCheckpointNV},
+    {"vkGetQueueCheckpointDataNV", (void*)GetQueueCheckpointDataNV},
+    {"vkGetQueueCheckpointData2NV", (void*)GetQueueCheckpointData2NV},
+    {"vkSetSwapchainPresentTimingQueueSizeEXT", (void*)SetSwapchainPresentTimingQueueSizeEXT},
+    {"vkGetSwapchainTimingPropertiesEXT", (void*)GetSwapchainTimingPropertiesEXT},
+    {"vkGetSwapchainTimeDomainPropertiesEXT", (void*)GetSwapchainTimeDomainPropertiesEXT},
+    {"vkGetPastPresentationTimingEXT", (void*)GetPastPresentationTimingEXT},
+    {"vkInitializePerformanceApiINTEL", (void*)InitializePerformanceApiINTEL},
+    {"vkUninitializePerformanceApiINTEL", (void*)UninitializePerformanceApiINTEL},
+    {"vkCmdSetPerformanceMarkerINTEL", (void*)CmdSetPerformanceMarkerINTEL},
+    {"vkCmdSetPerformanceStreamMarkerINTEL", (void*)CmdSetPerformanceStreamMarkerINTEL},
+    {"vkCmdSetPerformanceOverrideINTEL", (void*)CmdSetPerformanceOverrideINTEL},
+    {"vkAcquirePerformanceConfigurationINTEL", (void*)AcquirePerformanceConfigurationINTEL},
+    {"vkReleasePerformanceConfigurationINTEL", (void*)ReleasePerformanceConfigurationINTEL},
+    {"vkQueueSetPerformanceConfigurationINTEL", (void*)QueueSetPerformanceConfigurationINTEL},
+    {"vkGetPerformanceParameterINTEL", (void*)GetPerformanceParameterINTEL},
+    {"vkSetLocalDimmingAMD", (void*)SetLocalDimmingAMD},
+#ifdef VK_USE_PLATFORM_FUCHSIA
+    {"vkCreateImagePipeSurfaceFUCHSIA", (void*)CreateImagePipeSurfaceFUCHSIA},
+#endif
+#ifdef VK_USE_PLATFORM_METAL_EXT
+    {"vkCreateMetalSurfaceEXT", (void*)CreateMetalSurfaceEXT},
+#endif
+    {"vkGetBufferDeviceAddressEXT", (void*)GetBufferDeviceAddressEXT},
+    {"vkGetPhysicalDeviceToolPropertiesEXT", (void*)GetPhysicalDeviceToolPropertiesEXT},
+    {"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", (void*)GetPhysicalDeviceCooperativeMatrixPropertiesNV},
+    {"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV",
+     (void*)GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    {"vkGetPhysicalDeviceSurfacePresentModes2EXT", (void*)GetPhysicalDeviceSurfacePresentModes2EXT},
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    {"vkAcquireFullScreenExclusiveModeEXT", (void*)AcquireFullScreenExclusiveModeEXT},
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    {"vkReleaseFullScreenExclusiveModeEXT", (void*)ReleaseFullScreenExclusiveModeEXT},
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    {"vkGetDeviceGroupSurfacePresentModes2EXT", (void*)GetDeviceGroupSurfacePresentModes2EXT},
+#endif
+    {"vkCreateHeadlessSurfaceEXT", (void*)CreateHeadlessSurfaceEXT},
+    {"vkCmdSetLineStippleEXT", (void*)CmdSetLineStippleEXT},
+    {"vkResetQueryPoolEXT", (void*)ResetQueryPoolEXT},
+    {"vkCmdSetCullModeEXT", (void*)CmdSetCullModeEXT},
+    {"vkCmdSetFrontFaceEXT", (void*)CmdSetFrontFaceEXT},
+    {"vkCmdSetPrimitiveTopologyEXT", (void*)CmdSetPrimitiveTopologyEXT},
+    {"vkCmdSetViewportWithCountEXT", (void*)CmdSetViewportWithCountEXT},
+    {"vkCmdSetScissorWithCountEXT", (void*)CmdSetScissorWithCountEXT},
+    {"vkCmdBindVertexBuffers2EXT", (void*)CmdBindVertexBuffers2EXT},
+    {"vkCmdSetDepthTestEnableEXT", (void*)CmdSetDepthTestEnableEXT},
+    {"vkCmdSetDepthWriteEnableEXT", (void*)CmdSetDepthWriteEnableEXT},
+    {"vkCmdSetDepthCompareOpEXT", (void*)CmdSetDepthCompareOpEXT},
+    {"vkCmdSetDepthBoundsTestEnableEXT", (void*)CmdSetDepthBoundsTestEnableEXT},
+    {"vkCmdSetStencilTestEnableEXT", (void*)CmdSetStencilTestEnableEXT},
+    {"vkCmdSetStencilOpEXT", (void*)CmdSetStencilOpEXT},
+    {"vkCopyMemoryToImageEXT", (void*)CopyMemoryToImageEXT},
+    {"vkCopyImageToMemoryEXT", (void*)CopyImageToMemoryEXT},
+    {"vkCopyImageToImageEXT", (void*)CopyImageToImageEXT},
+    {"vkTransitionImageLayoutEXT", (void*)TransitionImageLayoutEXT},
+    {"vkGetImageSubresourceLayout2EXT", (void*)GetImageSubresourceLayout2EXT},
+    {"vkReleaseSwapchainImagesEXT", (void*)ReleaseSwapchainImagesEXT},
+    {"vkGetGeneratedCommandsMemoryRequirementsNV", (void*)GetGeneratedCommandsMemoryRequirementsNV},
+    {"vkCmdPreprocessGeneratedCommandsNV", (void*)CmdPreprocessGeneratedCommandsNV},
+    {"vkCmdExecuteGeneratedCommandsNV", (void*)CmdExecuteGeneratedCommandsNV},
+    {"vkCmdBindPipelineShaderGroupNV", (void*)CmdBindPipelineShaderGroupNV},
+    {"vkCreateIndirectCommandsLayoutNV", (void*)CreateIndirectCommandsLayoutNV},
+    {"vkDestroyIndirectCommandsLayoutNV", (void*)DestroyIndirectCommandsLayoutNV},
+    {"vkCmdSetDepthBias2EXT", (void*)CmdSetDepthBias2EXT},
+    {"vkAcquireDrmDisplayEXT", (void*)AcquireDrmDisplayEXT},
+    {"vkGetDrmDisplayEXT", (void*)GetDrmDisplayEXT},
+    {"vkCreatePrivateDataSlotEXT", (void*)CreatePrivateDataSlotEXT},
+    {"vkDestroyPrivateDataSlotEXT", (void*)DestroyPrivateDataSlotEXT},
+    {"vkSetPrivateDataEXT", (void*)SetPrivateDataEXT},
+    {"vkGetPrivateDataEXT", (void*)GetPrivateDataEXT},
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    {"vkCreateCudaModuleNV", (void*)CreateCudaModuleNV},
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    {"vkGetCudaModuleCacheNV", (void*)GetCudaModuleCacheNV},
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    {"vkCreateCudaFunctionNV", (void*)CreateCudaFunctionNV},
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    {"vkDestroyCudaModuleNV", (void*)DestroyCudaModuleNV},
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    {"vkDestroyCudaFunctionNV", (void*)DestroyCudaFunctionNV},
+#endif
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    {"vkCmdCudaLaunchKernelNV", (void*)CmdCudaLaunchKernelNV},
+#endif
+    {"vkCmdDispatchTileQCOM", (void*)CmdDispatchTileQCOM},
+    {"vkCmdBeginPerTileExecutionQCOM", (void*)CmdBeginPerTileExecutionQCOM},
+    {"vkCmdEndPerTileExecutionQCOM", (void*)CmdEndPerTileExecutionQCOM},
+#ifdef VK_USE_PLATFORM_METAL_EXT
+    {"vkExportMetalObjectsEXT", (void*)ExportMetalObjectsEXT},
+#endif
+    {"vkGetDescriptorSetLayoutSizeEXT", (void*)GetDescriptorSetLayoutSizeEXT},
+    {"vkGetDescriptorSetLayoutBindingOffsetEXT", (void*)GetDescriptorSetLayoutBindingOffsetEXT},
+    {"vkGetDescriptorEXT", (void*)GetDescriptorEXT},
+    {"vkCmdBindDescriptorBuffersEXT", (void*)CmdBindDescriptorBuffersEXT},
+    {"vkCmdSetDescriptorBufferOffsetsEXT", (void*)CmdSetDescriptorBufferOffsetsEXT},
+    {"vkCmdBindDescriptorBufferEmbeddedSamplersEXT", (void*)CmdBindDescriptorBufferEmbeddedSamplersEXT},
+    {"vkGetBufferOpaqueCaptureDescriptorDataEXT", (void*)GetBufferOpaqueCaptureDescriptorDataEXT},
+    {"vkGetImageOpaqueCaptureDescriptorDataEXT", (void*)GetImageOpaqueCaptureDescriptorDataEXT},
+    {"vkGetImageViewOpaqueCaptureDescriptorDataEXT", (void*)GetImageViewOpaqueCaptureDescriptorDataEXT},
+    {"vkGetSamplerOpaqueCaptureDescriptorDataEXT", (void*)GetSamplerOpaqueCaptureDescriptorDataEXT},
+    {"vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT", (void*)GetAccelerationStructureOpaqueCaptureDescriptorDataEXT},
+    {"vkCmdSetFragmentShadingRateEnumNV", (void*)CmdSetFragmentShadingRateEnumNV},
+    {"vkGetDeviceFaultInfoEXT", (void*)GetDeviceFaultInfoEXT},
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    {"vkAcquireWinrtDisplayNV", (void*)AcquireWinrtDisplayNV},
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    {"vkGetWinrtDisplayNV", (void*)GetWinrtDisplayNV},
+#endif
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+    {"vkCreateDirectFBSurfaceEXT", (void*)CreateDirectFBSurfaceEXT},
+#endif
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+    {"vkGetPhysicalDeviceDirectFBPresentationSupportEXT", (void*)GetPhysicalDeviceDirectFBPresentationSupportEXT},
+#endif
+    {"vkCmdSetVertexInputEXT", (void*)CmdSetVertexInputEXT},
+#ifdef VK_USE_PLATFORM_FUCHSIA
+    {"vkGetMemoryZirconHandleFUCHSIA", (void*)GetMemoryZirconHandleFUCHSIA},
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+    {"vkGetMemoryZirconHandlePropertiesFUCHSIA", (void*)GetMemoryZirconHandlePropertiesFUCHSIA},
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+    {"vkImportSemaphoreZirconHandleFUCHSIA", (void*)ImportSemaphoreZirconHandleFUCHSIA},
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+    {"vkGetSemaphoreZirconHandleFUCHSIA", (void*)GetSemaphoreZirconHandleFUCHSIA},
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+    {"vkCreateBufferCollectionFUCHSIA", (void*)CreateBufferCollectionFUCHSIA},
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+    {"vkSetBufferCollectionImageConstraintsFUCHSIA", (void*)SetBufferCollectionImageConstraintsFUCHSIA},
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+    {"vkSetBufferCollectionBufferConstraintsFUCHSIA", (void*)SetBufferCollectionBufferConstraintsFUCHSIA},
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+    {"vkDestroyBufferCollectionFUCHSIA", (void*)DestroyBufferCollectionFUCHSIA},
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+    {"vkGetBufferCollectionPropertiesFUCHSIA", (void*)GetBufferCollectionPropertiesFUCHSIA},
+#endif
+    {"vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI", (void*)GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI},
+    {"vkCmdSubpassShadingHUAWEI", (void*)CmdSubpassShadingHUAWEI},
+    {"vkCmdBindInvocationMaskHUAWEI", (void*)CmdBindInvocationMaskHUAWEI},
+    {"vkGetMemoryRemoteAddressNV", (void*)GetMemoryRemoteAddressNV},
+    {"vkGetPipelinePropertiesEXT", (void*)GetPipelinePropertiesEXT},
+    {"vkCmdSetPatchControlPointsEXT", (void*)CmdSetPatchControlPointsEXT},
+    {"vkCmdSetRasterizerDiscardEnableEXT", (void*)CmdSetRasterizerDiscardEnableEXT},
+    {"vkCmdSetDepthBiasEnableEXT", (void*)CmdSetDepthBiasEnableEXT},
+    {"vkCmdSetLogicOpEXT", (void*)CmdSetLogicOpEXT},
+    {"vkCmdSetPrimitiveRestartEnableEXT", (void*)CmdSetPrimitiveRestartEnableEXT},
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+    {"vkCreateScreenSurfaceQNX", (void*)CreateScreenSurfaceQNX},
+#endif
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+    {"vkGetPhysicalDeviceScreenPresentationSupportQNX", (void*)GetPhysicalDeviceScreenPresentationSupportQNX},
+#endif
+    {"vkCmdSetColorWriteEnableEXT", (void*)CmdSetColorWriteEnableEXT},
+    {"vkCmdDrawMultiEXT", (void*)CmdDrawMultiEXT},
+    {"vkCmdDrawMultiIndexedEXT", (void*)CmdDrawMultiIndexedEXT},
+    {"vkCreateMicromapEXT", (void*)CreateMicromapEXT},
+    {"vkDestroyMicromapEXT", (void*)DestroyMicromapEXT},
+    {"vkCmdBuildMicromapsEXT", (void*)CmdBuildMicromapsEXT},
+    {"vkBuildMicromapsEXT", (void*)BuildMicromapsEXT},
+    {"vkCopyMicromapEXT", (void*)CopyMicromapEXT},
+    {"vkCopyMicromapToMemoryEXT", (void*)CopyMicromapToMemoryEXT},
+    {"vkCopyMemoryToMicromapEXT", (void*)CopyMemoryToMicromapEXT},
+    {"vkWriteMicromapsPropertiesEXT", (void*)WriteMicromapsPropertiesEXT},
+    {"vkCmdCopyMicromapEXT", (void*)CmdCopyMicromapEXT},
+    {"vkCmdCopyMicromapToMemoryEXT", (void*)CmdCopyMicromapToMemoryEXT},
+    {"vkCmdCopyMemoryToMicromapEXT", (void*)CmdCopyMemoryToMicromapEXT},
+    {"vkCmdWriteMicromapsPropertiesEXT", (void*)CmdWriteMicromapsPropertiesEXT},
+    {"vkGetDeviceMicromapCompatibilityEXT", (void*)GetDeviceMicromapCompatibilityEXT},
+    {"vkGetMicromapBuildSizesEXT", (void*)GetMicromapBuildSizesEXT},
+    {"vkCmdDrawClusterHUAWEI", (void*)CmdDrawClusterHUAWEI},
+    {"vkCmdDrawClusterIndirectHUAWEI", (void*)CmdDrawClusterIndirectHUAWEI},
+    {"vkSetDeviceMemoryPriorityEXT", (void*)SetDeviceMemoryPriorityEXT},
+    {"vkGetDescriptorSetLayoutHostMappingInfoVALVE", (void*)GetDescriptorSetLayoutHostMappingInfoVALVE},
+    {"vkGetDescriptorSetHostMappingVALVE", (void*)GetDescriptorSetHostMappingVALVE},
+    {"vkCmdCopyMemoryIndirectNV", (void*)CmdCopyMemoryIndirectNV},
+    {"vkCmdCopyMemoryToImageIndirectNV", (void*)CmdCopyMemoryToImageIndirectNV},
+    {"vkCmdDecompressMemoryNV", (void*)CmdDecompressMemoryNV},
+    {"vkCmdDecompressMemoryIndirectCountNV", (void*)CmdDecompressMemoryIndirectCountNV},
+    {"vkGetPipelineIndirectMemoryRequirementsNV", (void*)GetPipelineIndirectMemoryRequirementsNV},
+    {"vkCmdUpdatePipelineIndirectBufferNV", (void*)CmdUpdatePipelineIndirectBufferNV},
+    {"vkGetPipelineIndirectDeviceAddressNV", (void*)GetPipelineIndirectDeviceAddressNV},
+#ifdef VK_USE_PLATFORM_OHOS
+    {"vkGetNativeBufferPropertiesOHOS", (void*)GetNativeBufferPropertiesOHOS},
+#endif
+#ifdef VK_USE_PLATFORM_OHOS
+    {"vkGetMemoryNativeBufferOHOS", (void*)GetMemoryNativeBufferOHOS},
+#endif
+    {"vkCmdSetDepthClampEnableEXT", (void*)CmdSetDepthClampEnableEXT},
+    {"vkCmdSetPolygonModeEXT", (void*)CmdSetPolygonModeEXT},
+    {"vkCmdSetRasterizationSamplesEXT", (void*)CmdSetRasterizationSamplesEXT},
+    {"vkCmdSetSampleMaskEXT", (void*)CmdSetSampleMaskEXT},
+    {"vkCmdSetAlphaToCoverageEnableEXT", (void*)CmdSetAlphaToCoverageEnableEXT},
+    {"vkCmdSetAlphaToOneEnableEXT", (void*)CmdSetAlphaToOneEnableEXT},
+    {"vkCmdSetLogicOpEnableEXT", (void*)CmdSetLogicOpEnableEXT},
+    {"vkCmdSetColorBlendEnableEXT", (void*)CmdSetColorBlendEnableEXT},
+    {"vkCmdSetColorBlendEquationEXT", (void*)CmdSetColorBlendEquationEXT},
+    {"vkCmdSetColorWriteMaskEXT", (void*)CmdSetColorWriteMaskEXT},
+    {"vkCmdSetTessellationDomainOriginEXT", (void*)CmdSetTessellationDomainOriginEXT},
+    {"vkCmdSetRasterizationStreamEXT", (void*)CmdSetRasterizationStreamEXT},
+    {"vkCmdSetConservativeRasterizationModeEXT", (void*)CmdSetConservativeRasterizationModeEXT},
+    {"vkCmdSetExtraPrimitiveOverestimationSizeEXT", (void*)CmdSetExtraPrimitiveOverestimationSizeEXT},
+    {"vkCmdSetDepthClipEnableEXT", (void*)CmdSetDepthClipEnableEXT},
+    {"vkCmdSetSampleLocationsEnableEXT", (void*)CmdSetSampleLocationsEnableEXT},
+    {"vkCmdSetColorBlendAdvancedEXT", (void*)CmdSetColorBlendAdvancedEXT},
+    {"vkCmdSetProvokingVertexModeEXT", (void*)CmdSetProvokingVertexModeEXT},
+    {"vkCmdSetLineRasterizationModeEXT", (void*)CmdSetLineRasterizationModeEXT},
+    {"vkCmdSetLineStippleEnableEXT", (void*)CmdSetLineStippleEnableEXT},
+    {"vkCmdSetDepthClipNegativeOneToOneEXT", (void*)CmdSetDepthClipNegativeOneToOneEXT},
+    {"vkCmdSetViewportWScalingEnableNV", (void*)CmdSetViewportWScalingEnableNV},
+    {"vkCmdSetViewportSwizzleNV", (void*)CmdSetViewportSwizzleNV},
+    {"vkCmdSetCoverageToColorEnableNV", (void*)CmdSetCoverageToColorEnableNV},
+    {"vkCmdSetCoverageToColorLocationNV", (void*)CmdSetCoverageToColorLocationNV},
+    {"vkCmdSetCoverageModulationModeNV", (void*)CmdSetCoverageModulationModeNV},
+    {"vkCmdSetCoverageModulationTableEnableNV", (void*)CmdSetCoverageModulationTableEnableNV},
+    {"vkCmdSetCoverageModulationTableNV", (void*)CmdSetCoverageModulationTableNV},
+    {"vkCmdSetShadingRateImageEnableNV", (void*)CmdSetShadingRateImageEnableNV},
+    {"vkCmdSetRepresentativeFragmentTestEnableNV", (void*)CmdSetRepresentativeFragmentTestEnableNV},
+    {"vkCmdSetCoverageReductionModeNV", (void*)CmdSetCoverageReductionModeNV},
+    {"vkCreateTensorARM", (void*)CreateTensorARM},
+    {"vkDestroyTensorARM", (void*)DestroyTensorARM},
+    {"vkCreateTensorViewARM", (void*)CreateTensorViewARM},
+    {"vkDestroyTensorViewARM", (void*)DestroyTensorViewARM},
+    {"vkGetTensorMemoryRequirementsARM", (void*)GetTensorMemoryRequirementsARM},
+    {"vkBindTensorMemoryARM", (void*)BindTensorMemoryARM},
+    {"vkGetDeviceTensorMemoryRequirementsARM", (void*)GetDeviceTensorMemoryRequirementsARM},
+    {"vkCmdCopyTensorARM", (void*)CmdCopyTensorARM},
+    {"vkGetPhysicalDeviceExternalTensorPropertiesARM", (void*)GetPhysicalDeviceExternalTensorPropertiesARM},
+    {"vkGetTensorOpaqueCaptureDescriptorDataARM", (void*)GetTensorOpaqueCaptureDescriptorDataARM},
+    {"vkGetTensorViewOpaqueCaptureDescriptorDataARM", (void*)GetTensorViewOpaqueCaptureDescriptorDataARM},
+    {"vkGetShaderModuleIdentifierEXT", (void*)GetShaderModuleIdentifierEXT},
+    {"vkGetShaderModuleCreateInfoIdentifierEXT", (void*)GetShaderModuleCreateInfoIdentifierEXT},
+    {"vkGetPhysicalDeviceOpticalFlowImageFormatsNV", (void*)GetPhysicalDeviceOpticalFlowImageFormatsNV},
+    {"vkCreateOpticalFlowSessionNV", (void*)CreateOpticalFlowSessionNV},
+    {"vkDestroyOpticalFlowSessionNV", (void*)DestroyOpticalFlowSessionNV},
+    {"vkBindOpticalFlowSessionImageNV", (void*)BindOpticalFlowSessionImageNV},
+    {"vkCmdOpticalFlowExecuteNV", (void*)CmdOpticalFlowExecuteNV},
+    {"vkAntiLagUpdateAMD", (void*)AntiLagUpdateAMD},
+    {"vkCreateShadersEXT", (void*)CreateShadersEXT},
+    {"vkDestroyShaderEXT", (void*)DestroyShaderEXT},
+    {"vkGetShaderBinaryDataEXT", (void*)GetShaderBinaryDataEXT},
+    {"vkCmdBindShadersEXT", (void*)CmdBindShadersEXT},
+    {"vkCmdSetDepthClampRangeEXT", (void*)CmdSetDepthClampRangeEXT},
+    {"vkGetFramebufferTilePropertiesQCOM", (void*)GetFramebufferTilePropertiesQCOM},
+    {"vkGetDynamicRenderingTilePropertiesQCOM", (void*)GetDynamicRenderingTilePropertiesQCOM},
+    {"vkGetPhysicalDeviceCooperativeVectorPropertiesNV", (void*)GetPhysicalDeviceCooperativeVectorPropertiesNV},
+    {"vkConvertCooperativeVectorMatrixNV", (void*)ConvertCooperativeVectorMatrixNV},
+    {"vkCmdConvertCooperativeVectorMatrixNV", (void*)CmdConvertCooperativeVectorMatrixNV},
+    {"vkSetLatencySleepModeNV", (void*)SetLatencySleepModeNV},
+    {"vkLatencySleepNV", (void*)LatencySleepNV},
+    {"vkSetLatencyMarkerNV", (void*)SetLatencyMarkerNV},
+    {"vkGetLatencyTimingsNV", (void*)GetLatencyTimingsNV},
+    {"vkQueueNotifyOutOfBandNV", (void*)QueueNotifyOutOfBandNV},
+    {"vkCreateDataGraphPipelinesARM", (void*)CreateDataGraphPipelinesARM},
+    {"vkCreateDataGraphPipelineSessionARM", (void*)CreateDataGraphPipelineSessionARM},
+    {"vkGetDataGraphPipelineSessionBindPointRequirementsARM", (void*)GetDataGraphPipelineSessionBindPointRequirementsARM},
+    {"vkGetDataGraphPipelineSessionMemoryRequirementsARM", (void*)GetDataGraphPipelineSessionMemoryRequirementsARM},
+    {"vkBindDataGraphPipelineSessionMemoryARM", (void*)BindDataGraphPipelineSessionMemoryARM},
+    {"vkDestroyDataGraphPipelineSessionARM", (void*)DestroyDataGraphPipelineSessionARM},
+    {"vkCmdDispatchDataGraphARM", (void*)CmdDispatchDataGraphARM},
+    {"vkGetDataGraphPipelineAvailablePropertiesARM", (void*)GetDataGraphPipelineAvailablePropertiesARM},
+    {"vkGetDataGraphPipelinePropertiesARM", (void*)GetDataGraphPipelinePropertiesARM},
+    {"vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM", (void*)GetPhysicalDeviceQueueFamilyDataGraphPropertiesARM},
+    {"vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM",
+     (void*)GetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM},
+    {"vkCmdSetAttachmentFeedbackLoopEnableEXT", (void*)CmdSetAttachmentFeedbackLoopEnableEXT},
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+    {"vkGetScreenBufferPropertiesQNX", (void*)GetScreenBufferPropertiesQNX},
+#endif
+    {"vkCmdBindTileMemoryQCOM", (void*)CmdBindTileMemoryQCOM},
+    {"vkCmdDecompressMemoryEXT", (void*)CmdDecompressMemoryEXT},
+    {"vkCmdDecompressMemoryIndirectCountEXT", (void*)CmdDecompressMemoryIndirectCountEXT},
+    {"vkCreateExternalComputeQueueNV", (void*)CreateExternalComputeQueueNV},
+    {"vkDestroyExternalComputeQueueNV", (void*)DestroyExternalComputeQueueNV},
+    {"vkGetExternalComputeQueueDataNV", (void*)GetExternalComputeQueueDataNV},
+    {"vkGetClusterAccelerationStructureBuildSizesNV", (void*)GetClusterAccelerationStructureBuildSizesNV},
+    {"vkCmdBuildClusterAccelerationStructureIndirectNV", (void*)CmdBuildClusterAccelerationStructureIndirectNV},
+    {"vkGetPartitionedAccelerationStructuresBuildSizesNV", (void*)GetPartitionedAccelerationStructuresBuildSizesNV},
+    {"vkCmdBuildPartitionedAccelerationStructuresNV", (void*)CmdBuildPartitionedAccelerationStructuresNV},
+    {"vkGetGeneratedCommandsMemoryRequirementsEXT", (void*)GetGeneratedCommandsMemoryRequirementsEXT},
+    {"vkCmdPreprocessGeneratedCommandsEXT", (void*)CmdPreprocessGeneratedCommandsEXT},
+    {"vkCmdExecuteGeneratedCommandsEXT", (void*)CmdExecuteGeneratedCommandsEXT},
+    {"vkCreateIndirectCommandsLayoutEXT", (void*)CreateIndirectCommandsLayoutEXT},
+    {"vkDestroyIndirectCommandsLayoutEXT", (void*)DestroyIndirectCommandsLayoutEXT},
+    {"vkCreateIndirectExecutionSetEXT", (void*)CreateIndirectExecutionSetEXT},
+    {"vkDestroyIndirectExecutionSetEXT", (void*)DestroyIndirectExecutionSetEXT},
+    {"vkUpdateIndirectExecutionSetPipelineEXT", (void*)UpdateIndirectExecutionSetPipelineEXT},
+    {"vkUpdateIndirectExecutionSetShaderEXT", (void*)UpdateIndirectExecutionSetShaderEXT},
+#ifdef VK_USE_PLATFORM_OHOS
+    {"vkCreateSurfaceOHOS", (void*)CreateSurfaceOHOS},
+#endif
+    {"vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV",
+     (void*)GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV},
+#ifdef VK_USE_PLATFORM_METAL_EXT
+    {"vkGetMemoryMetalHandleEXT", (void*)GetMemoryMetalHandleEXT},
+#endif
+#ifdef VK_USE_PLATFORM_METAL_EXT
+    {"vkGetMemoryMetalHandlePropertiesEXT", (void*)GetMemoryMetalHandlePropertiesEXT},
+#endif
+    {"vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM",
+     (void*)EnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM},
+    {"vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM", (void*)EnumeratePhysicalDeviceShaderInstrumentationMetricsARM},
+    {"vkCreateShaderInstrumentationARM", (void*)CreateShaderInstrumentationARM},
+    {"vkDestroyShaderInstrumentationARM", (void*)DestroyShaderInstrumentationARM},
+    {"vkCmdBeginShaderInstrumentationARM", (void*)CmdBeginShaderInstrumentationARM},
+    {"vkCmdEndShaderInstrumentationARM", (void*)CmdEndShaderInstrumentationARM},
+    {"vkGetShaderInstrumentationValuesARM", (void*)GetShaderInstrumentationValuesARM},
+    {"vkClearShaderInstrumentationMetricsARM", (void*)ClearShaderInstrumentationMetricsARM},
+    {"vkCmdEndRendering2EXT", (void*)CmdEndRendering2EXT},
+    {"vkCmdBeginCustomResolveEXT", (void*)CmdBeginCustomResolveEXT},
+    {"vkCmdSetComputeOccupancyPriorityNV", (void*)CmdSetComputeOccupancyPriorityNV},
+#ifdef VK_USE_PLATFORM_UBM_SEC
+    {"vkCreateUbmSurfaceSEC", (void*)CreateUbmSurfaceSEC},
+#endif
+#ifdef VK_USE_PLATFORM_UBM_SEC
+    {"vkGetPhysicalDeviceUbmPresentationSupportSEC", (void*)GetPhysicalDeviceUbmPresentationSupportSEC},
+#endif
+    {"vkCreateAccelerationStructureKHR", (void*)CreateAccelerationStructureKHR},
+    {"vkDestroyAccelerationStructureKHR", (void*)DestroyAccelerationStructureKHR},
+    {"vkCmdBuildAccelerationStructuresKHR", (void*)CmdBuildAccelerationStructuresKHR},
+    {"vkCmdBuildAccelerationStructuresIndirectKHR", (void*)CmdBuildAccelerationStructuresIndirectKHR},
+    {"vkBuildAccelerationStructuresKHR", (void*)BuildAccelerationStructuresKHR},
+    {"vkCopyAccelerationStructureKHR", (void*)CopyAccelerationStructureKHR},
+    {"vkCopyAccelerationStructureToMemoryKHR", (void*)CopyAccelerationStructureToMemoryKHR},
+    {"vkCopyMemoryToAccelerationStructureKHR", (void*)CopyMemoryToAccelerationStructureKHR},
+    {"vkWriteAccelerationStructuresPropertiesKHR", (void*)WriteAccelerationStructuresPropertiesKHR},
+    {"vkCmdCopyAccelerationStructureKHR", (void*)CmdCopyAccelerationStructureKHR},
+    {"vkCmdCopyAccelerationStructureToMemoryKHR", (void*)CmdCopyAccelerationStructureToMemoryKHR},
+    {"vkCmdCopyMemoryToAccelerationStructureKHR", (void*)CmdCopyMemoryToAccelerationStructureKHR},
+    {"vkGetAccelerationStructureDeviceAddressKHR", (void*)GetAccelerationStructureDeviceAddressKHR},
+    {"vkCmdWriteAccelerationStructuresPropertiesKHR", (void*)CmdWriteAccelerationStructuresPropertiesKHR},
+    {"vkGetDeviceAccelerationStructureCompatibilityKHR", (void*)GetDeviceAccelerationStructureCompatibilityKHR},
+    {"vkGetAccelerationStructureBuildSizesKHR", (void*)GetAccelerationStructureBuildSizesKHR},
+    {"vkCmdTraceRaysKHR", (void*)CmdTraceRaysKHR},
+    {"vkCreateRayTracingPipelinesKHR", (void*)CreateRayTracingPipelinesKHR},
+    {"vkGetRayTracingCaptureReplayShaderGroupHandlesKHR", (void*)GetRayTracingCaptureReplayShaderGroupHandlesKHR},
+    {"vkCmdTraceRaysIndirectKHR", (void*)CmdTraceRaysIndirectKHR},
+    {"vkGetRayTracingShaderGroupStackSizeKHR", (void*)GetRayTracingShaderGroupStackSizeKHR},
+    {"vkCmdSetRayTracingPipelineStackSizeKHR", (void*)CmdSetRayTracingPipelineStackSizeKHR},
+    {"vkCmdDrawMeshTasksEXT", (void*)CmdDrawMeshTasksEXT},
+    {"vkCmdDrawMeshTasksIndirectEXT", (void*)CmdDrawMeshTasksIndirectEXT},
+    {"vkCmdDrawMeshTasksIndirectCountEXT", (void*)CmdDrawMeshTasksIndirectCountEXT},
+};
+
+}  // namespace vkmock
diff --git a/tools/Vulkan-Tools/icd/generated/function_definitions.h b/tools/Vulkan-Tools/icd/generated/function_definitions.h
new file mode 100644
index 00000000..8b0b7815
--- /dev/null
+++ b/tools/Vulkan-Tools/icd/generated/function_definitions.h
@@ -0,0 +1,4767 @@
+/*
+** Copyright (c) 2015-2025 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+#pragma once
+#include "mock_icd.h"
+#include "function_declarations.h"
+namespace vkmock {
+static VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo* pCreateInfo,
+                                                     const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) {
+    // TODO: If loader ver <=4 ICD must fail with VK_ERROR_INCOMPATIBLE_DRIVER for all vkCreateInstance calls with
+    //  apiVersion set to > Vulkan 1.0 because the loader is still at interface version <= 4. Otherwise, the
+    //  ICD should behave as normal.
+    if (loader_interface_version <= 4) {
+        return VK_ERROR_INCOMPATIBLE_DRIVER;
+    }
+    *pInstance = (VkInstance)CreateDispObjHandle();
+    for (auto& physical_device : physical_device_map[*pInstance]) physical_device = (VkPhysicalDevice)CreateDispObjHandle();
+    // TODO: If emulating specific device caps, will need to add intelligence here
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {
+    if (instance) {
+        for (const auto physical_device : physical_device_map.at(instance)) {
+            display_map.erase(physical_device);
+            DestroyDispObjHandle((void*)physical_device);
+        }
+        physical_device_map.erase(instance);
+        DestroyDispObjHandle((void*)instance);
+    }
+}
+static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount,
+                                                               VkPhysicalDevice* pPhysicalDevices) {
+    VkResult result_code = VK_SUCCESS;
+    if (pPhysicalDevices) {
+        const auto return_count = (std::min)(*pPhysicalDeviceCount, icd_physical_device_count);
+        for (uint32_t i = 0; i < return_count; ++i) pPhysicalDevices[i] = physical_device_map.at(instance)[i];
+        if (return_count < icd_physical_device_count) result_code = VK_INCOMPLETE;
+        *pPhysicalDeviceCount = return_count;
+    } else {
+        *pPhysicalDeviceCount = icd_physical_device_count;
+    }
+    return result_code;
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
+    uint32_t num_bools = sizeof(VkPhysicalDeviceFeatures) / sizeof(VkBool32);
+    VkBool32* bool_array = &pFeatures->robustBufferAccess;
+    SetBoolArrayTrue(bool_array, num_bools);
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
+                                                                    VkFormatProperties* pFormatProperties) {
+    if (VK_FORMAT_UNDEFINED == format) {
+        *pFormatProperties = {0x0, 0x0, 0x0};
+    } else {
+        // Default to a color format, skip DS bit
+        *pFormatProperties = {0x00FFFDFF, 0x00FFFDFF, 0x00FFFDFF};
+        switch (format) {
+            case VK_FORMAT_D16_UNORM:
+            case VK_FORMAT_X8_D24_UNORM_PACK32:
+            case VK_FORMAT_D32_SFLOAT:
+            case VK_FORMAT_S8_UINT:
+            case VK_FORMAT_D16_UNORM_S8_UINT:
+            case VK_FORMAT_D24_UNORM_S8_UINT:
+            case VK_FORMAT_D32_SFLOAT_S8_UINT:
+                // Don't set color bits for DS formats
+                *pFormatProperties = {0x00FFFE7F, 0x00FFFE7F, 0x00FFFE7F};
+                break;
+            case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
+            case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
+            case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
+            case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
+            case VK_FORMAT_G8_B8R8_2PLANE_444_UNORM:
+                // Set decode/encode bits for these formats
+                *pFormatProperties = {0x1EFFFDFF, 0x1EFFFDFF, 0x00FFFDFF};
+                break;
+            default:
+                break;
+        }
+    }
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
+                                                                             VkImageType type, VkImageTiling tiling,
+                                                                             VkImageUsageFlags usage, VkImageCreateFlags flags,
+                                                                             VkImageFormatProperties* pImageFormatProperties) {
+    // A hardcoded unsupported format
+    if (format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32) {
+        return VK_ERROR_FORMAT_NOT_SUPPORTED;
+    }
+
+    // TODO: Just hard-coding some values for now
+    // TODO: If tiling is linear, limit the mips, levels, & sample count
+    if (VK_IMAGE_TILING_LINEAR == tiling) {
+        *pImageFormatProperties = {{4096, 4096, 256}, 1, 1, VK_SAMPLE_COUNT_1_BIT, 4294967296};
+    } else {
+        // We hard-code support for all sample counts except 64 bits.
+        *pImageFormatProperties = {{4096, 4096, 256}, 12, 256, 0x7F & ~VK_SAMPLE_COUNT_64_BIT, 4294967296};
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
+                                                              VkPhysicalDeviceProperties* pProperties) {
+    pProperties->apiVersion = VK_HEADER_VERSION_COMPLETE;
+    pProperties->driverVersion = 1;
+    pProperties->vendorID = 0xba5eba11;
+    pProperties->deviceID = 0xf005ba11;
+    pProperties->deviceType = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU;
+    // std::string devName = "Vulkan Mock Device";
+    strcpy(pProperties->deviceName, "Vulkan Mock Device");
+    pProperties->pipelineCacheUUID[0] = 18;
+    pProperties->limits = SetLimits(&pProperties->limits);
+    pProperties->sparseProperties = {VK_TRUE, VK_TRUE, VK_TRUE, VK_TRUE, VK_TRUE};
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
+                                                                         uint32_t* pQueueFamilyPropertyCount,
+                                                                         VkQueueFamilyProperties* pQueueFamilyProperties) {
+    if (pQueueFamilyProperties) {
+        std::vector<VkQueueFamilyProperties2KHR> props2(*pQueueFamilyPropertyCount,
+                                                        {VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR});
+        GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, props2.data());
+        for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; ++i) {
+            pQueueFamilyProperties[i] = props2[i].queueFamilyProperties;
+        }
+    } else {
+        GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, nullptr);
+    }
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,
+                                                                    VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
+    pMemoryProperties->memoryTypeCount = 6;
+    // Host visible Coherent
+    pMemoryProperties->memoryTypes[0].propertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+    pMemoryProperties->memoryTypes[0].heapIndex = 0;
+    // Host visible Cached
+    pMemoryProperties->memoryTypes[1].propertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
+    pMemoryProperties->memoryTypes[1].heapIndex = 0;
+    // Device local and Host visible
+    pMemoryProperties->memoryTypes[2].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+                                                      VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+    pMemoryProperties->memoryTypes[2].heapIndex = 1;
+    // Device local lazily
+    pMemoryProperties->memoryTypes[3].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT;
+    pMemoryProperties->memoryTypes[3].heapIndex = 1;
+    // Device local protected
+    pMemoryProperties->memoryTypes[4].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_PROTECTED_BIT;
+    pMemoryProperties->memoryTypes[4].heapIndex = 1;
+    // Device local only
+    pMemoryProperties->memoryTypes[5].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+    pMemoryProperties->memoryTypes[5].heapIndex = 1;
+    pMemoryProperties->memoryHeapCount = 2;
+    pMemoryProperties->memoryHeaps[0].flags = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT;
+    pMemoryProperties->memoryHeaps[0].size = 8000000000;
+    pMemoryProperties->memoryHeaps[1].flags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT;
+    pMemoryProperties->memoryHeaps[1].size = 8000000000;
+}
+static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char* pName) {
+    if (!negotiate_loader_icd_interface_called) {
+        loader_interface_version = 0;
+    }
+    const auto& item = name_to_funcptr_map.find(pName);
+    if (item != name_to_funcptr_map.end()) {
+        return reinterpret_cast<PFN_vkVoidFunction>(item->second);
+    }
+    // Mock should intercept all functions so if we get here just return null
+    return nullptr;
+}
+static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char* pName) {
+    return GetInstanceProcAddr(nullptr, pName);
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo,
+                                                   const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {
+    *pDevice = (VkDevice)CreateDispObjHandle();
+    // TODO: If emulating specific device caps, will need to add intelligence here
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
+    unique_lock_t lock(global_lock);
+    // First destroy sub-device objects
+    // Destroy Queues
+    for (auto queue_family_map_pair : queue_map[device]) {
+        for (auto index_queue_pair : queue_map[device][queue_family_map_pair.first]) {
+            DestroyDispObjHandle((void*)index_queue_pair.second);
+        }
+    }
+
+    for (auto& cp : command_pool_map[device]) {
+        for (auto& cb : command_pool_buffer_map[cp]) {
+            DestroyDispObjHandle((void*)cb);
+        }
+        command_pool_buffer_map.erase(cp);
+    }
+    command_pool_map[device].clear();
+
+    queue_map.erase(device);
+    buffer_map.erase(device);
+    image_memory_size_map.erase(device);
+    // Now destroy device
+    DestroyDispObjHandle((void*)device);
+    // TODO: If emulating specific device caps, will need to add intelligence here
+}
+static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount,
+                                                                           VkExtensionProperties* pProperties) {
+    // If requesting number of extensions, return that
+    if (!pLayerName) {
+        if (!pProperties) {
+            *pPropertyCount = (uint32_t)instance_extension_map.size();
+        } else {
+            uint32_t i = 0;
+            for (const auto& name_ver_pair : instance_extension_map) {
+                if (i == *pPropertyCount) {
+                    break;
+                }
+                std::strncpy(pProperties[i].extensionName, name_ver_pair.first.c_str(), sizeof(pProperties[i].extensionName));
+                pProperties[i].extensionName[sizeof(pProperties[i].extensionName) - 1] = 0;
+                pProperties[i].specVersion = name_ver_pair.second;
+                ++i;
+            }
+            if (i != instance_extension_map.size()) {
+                return VK_INCOMPLETE;
+            }
+        }
+    }
+    // If requesting extension properties, fill in data struct for number of extensions
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName,
+                                                                         uint32_t* pPropertyCount,
+                                                                         VkExtensionProperties* pProperties) {
+    // If requesting number of extensions, return that
+    if (!pLayerName) {
+        if (!pProperties) {
+            *pPropertyCount = (uint32_t)device_extension_map.size();
+        } else {
+            uint32_t i = 0;
+            for (const auto& name_ver_pair : device_extension_map) {
+                if (i == *pPropertyCount) {
+                    break;
+                }
+                std::strncpy(pProperties[i].extensionName, name_ver_pair.first.c_str(), sizeof(pProperties[i].extensionName));
+                pProperties[i].extensionName[sizeof(pProperties[i].extensionName) - 1] = 0;
+                pProperties[i].specVersion = name_ver_pair.second;
+                ++i;
+            }
+            *pPropertyCount = i;
+            if (i != device_extension_map.size()) {
+                return VK_INCOMPLETE;
+            }
+        }
+    }
+    // If requesting extension properties, fill in data struct for number of extensions
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount,
+                                                                     VkLayerProperties* pProperties) {
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {
+    unique_lock_t lock(global_lock);
+    auto queue = queue_map[device][queueFamilyIndex][queueIndex];
+    if (queue) {
+        *pQueue = queue;
+    } else {
+        *pQueue = queue_map[device][queueFamilyIndex][queueIndex] = (VkQueue)CreateDispObjHandle();
+    }
+    // TODO: If emulating specific device caps, will need to add intelligence here
+    return;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits,
+                                                  VkFence fence) {
+    // Special way to cause DEVICE_LOST
+    // Picked VkExportFenceCreateInfo because needed some struct that wouldn't get cleared by validation Safe Struct
+    // ... TODO - It would be MUCH nicer to have a layer or other setting control when this occured
+    // For now this is used to allow Validation Layers test reacting to device losts
+    if (submitCount > 0 && pSubmits) {
+        auto pNext = reinterpret_cast<const VkBaseInStructure*>(pSubmits[0].pNext);
+        if (pNext && pNext->sType == VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO && pNext->pNext == nullptr) {
+            return VK_ERROR_DEVICE_LOST;
+        }
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle(VkQueue queue) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle(VkDevice device) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo,
+                                                     const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) {
+    unique_lock_t lock(global_lock);
+    allocated_memory_size_map[(VkDeviceMemory)global_unique_handle] = pAllocateInfo->allocationSize;
+    *pMemory = (VkDeviceMemory)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL FreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+    UnmapMemory(device, memory);
+    unique_lock_t lock(global_lock);
+    allocated_memory_size_map.erase(memory);
+}
+static VKAPI_ATTR VkResult VKAPI_CALL MapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size,
+                                                VkMemoryMapFlags flags, void** ppData) {
+    unique_lock_t lock(global_lock);
+    if (VK_WHOLE_SIZE == size) {
+        if (allocated_memory_size_map.count(memory) != 0)
+            size = allocated_memory_size_map[memory] - offset;
+        else
+            size = 0x10000;
+    }
+    void* map_addr = malloc((size_t)size);
+    mapped_memory_map[memory].push_back(map_addr);
+    *ppData = map_addr;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL UnmapMemory(VkDevice device, VkDeviceMemory memory) {
+    unique_lock_t lock(global_lock);
+    for (auto map_addr : mapped_memory_map[memory]) {
+        free(map_addr);
+    }
+    mapped_memory_map.erase(memory);
+}
+static VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
+                                                              const VkMappedMemoryRange* pMemoryRanges) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
+                                                                   const VkMappedMemoryRange* pMemoryRanges) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
+                                                            VkDeviceSize* pCommittedMemoryInBytes) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory,
+                                                       VkDeviceSize memoryOffset) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory,
+                                                      VkDeviceSize memoryOffset) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
+                                                              VkMemoryRequirements* pMemoryRequirements) {
+    // TODO: Just hard-coding reqs for now
+    pMemoryRequirements->size = 4096;
+    pMemoryRequirements->alignment = 1;
+    pMemoryRequirements->memoryTypeBits = 0xFFFF;
+    // Return a better size based on the buffer size from the create info.
+    unique_lock_t lock(global_lock);
+    auto d_iter = buffer_map.find(device);
+    if (d_iter != buffer_map.end()) {
+        auto iter = d_iter->second.find(buffer);
+        if (iter != d_iter->second.end()) {
+            pMemoryRequirements->size = ((iter->second.size + 4095) / 4096) * 4096;
+        }
+    }
+}
+static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements(VkDevice device, VkImage image,
+                                                             VkMemoryRequirements* pMemoryRequirements) {
+    pMemoryRequirements->size = 0;
+    pMemoryRequirements->alignment = 1;
+
+    unique_lock_t lock(global_lock);
+    auto d_iter = image_memory_size_map.find(device);
+    if (d_iter != image_memory_size_map.end()) {
+        auto iter = d_iter->second.find(image);
+        if (iter != d_iter->second.end()) {
+            pMemoryRequirements->size = iter->second;
+        }
+    }
+    // Here we hard-code that the memory type at index 3 doesn't support this image.
+    pMemoryRequirements->memoryTypeBits = 0xFFFF & ~(0x1 << 3);
+}
+static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements(VkDevice device, VkImage image,
+                                                                   uint32_t* pSparseMemoryRequirementCount,
+                                                                   VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
+    if (!pSparseMemoryRequirements) {
+        *pSparseMemoryRequirementCount = 1;
+    } else {
+        // arbitrary
+        pSparseMemoryRequirements->imageMipTailFirstLod = 0;
+        pSparseMemoryRequirements->imageMipTailSize = 8;
+        pSparseMemoryRequirements->imageMipTailOffset = 0;
+        pSparseMemoryRequirements->imageMipTailStride = 4;
+        pSparseMemoryRequirements->formatProperties.imageGranularity = {4, 4, 4};
+        pSparseMemoryRequirements->formatProperties.flags = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT;
+        // Would need to track the VkImage to know format for better value here
+        pSparseMemoryRequirements->formatProperties.aspectMask =
+            VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT;
+    }
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
+                                                                               VkImageType type, VkSampleCountFlagBits samples,
+                                                                               VkImageUsageFlags usage, VkImageTiling tiling,
+                                                                               uint32_t* pPropertyCount,
+                                                                               VkSparseImageFormatProperties* pProperties) {
+    if (!pProperties) {
+        *pPropertyCount = 1;
+    } else {
+        // arbitrary
+        pProperties->imageGranularity = {4, 4, 4};
+        pProperties->flags = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT;
+        switch (format) {
+            case VK_FORMAT_D16_UNORM:
+            case VK_FORMAT_D32_SFLOAT:
+                pProperties->aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
+                break;
+            case VK_FORMAT_S8_UINT:
+                pProperties->aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
+                break;
+            case VK_FORMAT_X8_D24_UNORM_PACK32:
+            case VK_FORMAT_D16_UNORM_S8_UINT:
+            case VK_FORMAT_D24_UNORM_S8_UINT:
+            case VK_FORMAT_D32_SFLOAT_S8_UINT:
+                pProperties->aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
+                break;
+            default:
+                pProperties->aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+                break;
+        }
+    }
+}
+static VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo,
+                                                      VkFence fence) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo,
+                                                  const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
+    unique_lock_t lock(global_lock);
+    *pFence = (VkFence)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus(VkDevice device, VkFence fence) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll,
+                                                    uint64_t timeout) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo,
+                                                      const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) {
+    unique_lock_t lock(global_lock);
+    *pSemaphore = (VkSemaphore)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroySemaphore(VkDevice device, VkSemaphore semaphore,
+                                                   const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo,
+                                                      const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) {
+    unique_lock_t lock(global_lock);
+    *pQueryPool = (VkQueryPool)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyQueryPool(VkDevice device, VkQueryPool queryPool,
+                                                   const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
+                                                          uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride,
+                                                          VkQueryResultFlags flags) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo,
+                                                   const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
+    unique_lock_t lock(global_lock);
+    *pBuffer = (VkBuffer)global_unique_handle++;
+    buffer_map[device][*pBuffer] = {pCreateInfo->size, current_available_address};
+    current_available_address += pCreateInfo->size;
+    // Always align to next 64-bit pointer
+    const uint64_t alignment = current_available_address % 64;
+    if (alignment != 0) {
+        current_available_address += (64 - alignment);
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) {
+    unique_lock_t lock(global_lock);
+    buffer_map[device].erase(buffer);
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo,
+                                                  const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
+    unique_lock_t lock(global_lock);
+    *pImage = (VkImage)global_unique_handle++;
+    image_memory_size_map[device][*pImage] = GetImageSizeFromCreateInfo(pCreateInfo);
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) {
+    unique_lock_t lock(global_lock);
+    image_memory_size_map[device].erase(image);
+}
+static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource,
+                                                            VkSubresourceLayout* pLayout) {
+    // Need safe values. Callers are computing memory offsets from pLayout, with no return code to flag failure.
+    *pLayout = VkSubresourceLayout();  // Default constructor zero values.
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo,
+                                                      const VkAllocationCallbacks* pAllocator, VkImageView* pView) {
+    unique_lock_t lock(global_lock);
+    *pView = (VkImageView)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyImageView(VkDevice device, VkImageView imageView,
+                                                   const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo,
+                                                        const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) {
+    unique_lock_t lock(global_lock);
+    *pCommandPool = (VkCommandPool)global_unique_handle++;
+    command_pool_map[device].insert(*pCommandPool);
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(VkDevice device, VkCommandPool commandPool,
+                                                     const VkAllocationCallbacks* pAllocator) {
+    // destroy command buffers for this pool
+    unique_lock_t lock(global_lock);
+    auto it = command_pool_buffer_map.find(commandPool);
+    if (it != command_pool_buffer_map.end()) {
+        for (auto& cb : it->second) {
+            DestroyDispObjHandle((void*)cb);
+        }
+        command_pool_buffer_map.erase(it);
+    }
+    command_pool_map[device].erase(commandPool);
+}
+static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo,
+                                                             VkCommandBuffer* pCommandBuffers) {
+    unique_lock_t lock(global_lock);
+    for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; ++i) {
+        pCommandBuffers[i] = (VkCommandBuffer)CreateDispObjHandle();
+        command_pool_buffer_map[pAllocateInfo->commandPool].push_back(pCommandBuffers[i]);
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount,
+                                                     const VkCommandBuffer* pCommandBuffers) {
+    unique_lock_t lock(global_lock);
+    for (auto i = 0u; i < commandBufferCount; ++i) {
+        if (!pCommandBuffers[i]) {
+            continue;
+        }
+
+        for (auto& pair : command_pool_buffer_map) {
+            auto& cbs = pair.second;
+            auto it = std::find(cbs.begin(), cbs.end(), pCommandBuffers[i]);
+            if (it != cbs.end()) {
+                cbs.erase(it);
+            }
+        }
+
+        DestroyDispObjHandle((void*)pCommandBuffers[i]);
+    }
+}
+static VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(VkCommandBuffer commandBuffer,
+                                                         const VkCommandBufferBeginInfo* pBeginInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(VkCommandBuffer commandBuffer) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer,
+                                                uint32_t regionCount, const VkBufferCopy* pRegions) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
+                                               VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
+                                               const VkImageCopy* pRegions) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
+                                                       VkImageLayout dstImageLayout, uint32_t regionCount,
+                                                       const VkBufferImageCopy* pRegions) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
+                                                       VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount,
+                                                       const VkBufferImageCopy* pRegions) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
+                                                  VkDeviceSize dataSize, const void* pData) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
+                                                VkDeviceSize size, uint32_t data) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
+                                                     VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
+                                                     uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers,
+                                                     uint32_t bufferMemoryBarrierCount,
+                                                     const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+                                                     uint32_t imageMemoryBarrierCount,
+                                                     const VkImageMemoryBarrier* pImageMemoryBarriers) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query,
+                                                VkQueryControlFlags flags) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
+                                                    uint32_t queryCount) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage,
+                                                    VkQueryPool queryPool, uint32_t query) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
+                                                          uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset,
+                                                          VkDeviceSize stride, VkQueryResultFlags flags) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount,
+                                                     const VkCommandBuffer* pCommandBuffers) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo,
+                                                  const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
+    unique_lock_t lock(global_lock);
+    *pEvent = (VkEvent)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus(VkDevice device, VkEvent event) {
+    // Not a CREATE or DESTROY function
+    return VK_EVENT_SET;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL SetEvent(VkDevice device, VkEvent event) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL ResetEvent(VkDevice device, VkEvent event) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo,
+                                                       const VkAllocationCallbacks* pAllocator, VkBufferView* pView) {
+    unique_lock_t lock(global_lock);
+    *pView = (VkBufferView)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyBufferView(VkDevice device, VkBufferView bufferView,
+                                                    const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo,
+                                                         const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) {
+    unique_lock_t lock(global_lock);
+    *pShaderModule = (VkShaderModule)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
+                                                      const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo,
+                                                          const VkAllocationCallbacks* pAllocator,
+                                                          VkPipelineCache* pPipelineCache) {
+    unique_lock_t lock(global_lock);
+    *pPipelineCache = (VkPipelineCache)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
+                                                       const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize,
+                                                           void* pData) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount,
+                                                          const VkPipelineCache* pSrcCaches) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache,
+                                                             uint32_t createInfoCount,
+                                                             const VkComputePipelineCreateInfo* pCreateInfos,
+                                                             const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
+    unique_lock_t lock(global_lock);
+    for (uint32_t i = 0; i < createInfoCount; ++i) {
+        pPipelines[i] = (VkPipeline)global_unique_handle++;
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo,
+                                                           const VkAllocationCallbacks* pAllocator,
+                                                           VkPipelineLayout* pPipelineLayout) {
+    unique_lock_t lock(global_lock);
+    *pPipelineLayout = (VkPipelineLayout)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
+                                                        const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo,
+                                                    const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) {
+    unique_lock_t lock(global_lock);
+    *pSampler = (VkSampler)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+                                                                const VkAllocationCallbacks* pAllocator,
+                                                                VkDescriptorSetLayout* pSetLayout) {
+    unique_lock_t lock(global_lock);
+    *pSetLayout = (VkDescriptorSetLayout)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout,
+                                                             const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo,
+                                                           const VkAllocationCallbacks* pAllocator,
+                                                           VkDescriptorPool* pDescriptorPool) {
+    unique_lock_t lock(global_lock);
+    *pDescriptorPool = (VkDescriptorPool)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+                                                        const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+                                                          VkDescriptorPoolResetFlags flags) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo,
+                                                             VkDescriptorSet* pDescriptorSets) {
+    unique_lock_t lock(global_lock);
+    for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; ++i) {
+        pDescriptorSets[i] = (VkDescriptorSet)global_unique_handle++;
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
+                                                         uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) {
+    // Destroy object
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
+                                                       const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount,
+                                                       const VkCopyDescriptorSet* pDescriptorCopies) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
+                                                  VkPipeline pipeline) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
+                                                        VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount,
+                                                        const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount,
+                                                        const uint32_t* pDynamicOffsets) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
+                                                     const VkClearColorValue* pColor, uint32_t rangeCount,
+                                                     const VkImageSubresourceRange* pRanges) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY,
+                                              uint32_t groupCountZ) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents,
+                                                VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask,
+                                                uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers,
+                                                uint32_t bufferMemoryBarrierCount,
+                                                const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+                                                uint32_t imageMemoryBarrierCount,
+                                                const VkImageMemoryBarrier* pImageMemoryBarriers) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
+                                                   VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size,
+                                                   const void* pValues) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
+                                                              uint32_t createInfoCount,
+                                                              const VkGraphicsPipelineCreateInfo* pCreateInfos,
+                                                              const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
+    unique_lock_t lock(global_lock);
+    for (uint32_t i = 0; i < createInfoCount; ++i) {
+        pPipelines[i] = (VkPipeline)global_unique_handle++;
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo,
+                                                        const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) {
+    unique_lock_t lock(global_lock);
+    *pFramebuffer = (VkFramebuffer)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
+                                                     const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo,
+                                                       const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
+    unique_lock_t lock(global_lock);
+    *pRenderPass = (VkRenderPass)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(VkDevice device, VkRenderPass renderPass,
+                                                    const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
+    pGranularity->width = 1;
+    pGranularity->height = 1;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount,
+                                                 const VkViewport* pViewports) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount,
+                                                const VkRect2D* pScissors) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor,
+                                                  float depthBiasClamp, float depthBiasSlopeFactor) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+                                                           uint32_t compareMask) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+                                                         uint32_t writeMask) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+                                                         uint32_t reference) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                     VkIndexType indexType) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount,
+                                                       const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount,
+                                          uint32_t firstVertex, uint32_t firstInstance) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount,
+                                                 uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                  uint32_t drawCount, uint32_t stride) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                         uint32_t drawCount, uint32_t stride) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
+                                               VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
+                                               const VkImageBlit* pRegions, VkFilter filter) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
+                                                            const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount,
+                                                            const VkImageSubresourceRange* pRanges) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
+                                                      const VkClearAttachment* pAttachments, uint32_t rectCount,
+                                                      const VkClearRect* pRects) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
+                                                  VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
+                                                  const VkImageResolve* pRegions) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin,
+                                                     VkSubpassContents contents) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass(VkCommandBuffer commandBuffer) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceVersion(uint32_t* pApiVersion) {
+    *pApiVersion = VK_HEADER_VERSION_COMPLETE;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
+                                                        const VkBindBufferMemoryInfo* pBindInfos) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2(VkDevice device, uint32_t bindInfoCount,
+                                                       const VkBindImageMemoryInfo* pBindInfos) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex,
+                                                                   uint32_t remoteDeviceIndex,
+                                                                   VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroups(
+    VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
+    return EnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
+}
+static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo,
+                                                              VkMemoryRequirements2* pMemoryRequirements) {
+    GetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
+}
+static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo,
+                                                               VkMemoryRequirements2* pMemoryRequirements) {
+    GetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
+}
+static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2(VkDevice device,
+                                                                    const VkImageSparseMemoryRequirementsInfo2* pInfo,
+                                                                    uint32_t* pSparseMemoryRequirementCount,
+                                                                    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
+    GetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,
+                                                             VkPhysicalDeviceFeatures2* pFeatures) {
+    GetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures);
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
+                                                               VkPhysicalDeviceProperties2* pProperties) {
+    GetPhysicalDeviceProperties2KHR(physicalDevice, pProperties);
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format,
+                                                                     VkFormatProperties2* pFormatProperties) {
+    GetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties);
+}
+static VKAPI_ATTR VkResult VKAPI_CALL
+GetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+                                        VkImageFormatProperties2* pImageFormatProperties) {
+    return GetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties);
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice,
+                                                                          uint32_t* pQueueFamilyPropertyCount,
+                                                                          VkQueueFamilyProperties2* pQueueFamilyProperties) {
+    GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice,
+                                                                     VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
+    GetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties);
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount,
+    VkSparseImageFormatProperties2* pProperties) {
+    GetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
+}
+static VKAPI_ATTR void VKAPI_CALL TrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) {
+    GetDeviceQueue(device, pQueueInfo->queueFamilyIndex, pQueueInfo->queueIndex, pQueue);
+    // TODO: Add further support for GetDeviceQueue2 features
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferProperties(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+    VkExternalBufferProperties* pExternalBufferProperties) {
+    constexpr VkExternalMemoryHandleTypeFlags supported_flags = 0x1FF;
+    if (pExternalBufferInfo->handleType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID) {
+        // Can't have dedicated memory with AHB
+        pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures =
+            VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
+        pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes = pExternalBufferInfo->handleType;
+        pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = pExternalBufferInfo->handleType;
+    } else if (pExternalBufferInfo->handleType & supported_flags) {
+        pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures = 0x7;
+        pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes = supported_flags;
+        pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = supported_flags;
+    } else {
+        pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures = 0;
+        pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes = 0;
+        // According to spec, handle type is always compatible with itself. Even if export/import
+        // not supported, it's important to properly implement self-compatibility property since
+        // application's control flow can rely on this.
+        pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = pExternalBufferInfo->handleType;
+    }
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFenceProperties(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+    VkExternalFenceProperties* pExternalFenceProperties) {
+    // Hard-code support for all handle types and features
+    pExternalFenceProperties->exportFromImportedHandleTypes = 0xF;
+    pExternalFenceProperties->compatibleHandleTypes = 0xF;
+    pExternalFenceProperties->externalFenceFeatures = 0x3;
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphoreProperties(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+    VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
+    // Hard code support for all handle types and features
+    pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0x1F;
+    pExternalSemaphoreProperties->compatibleHandleTypes = 0x1F;
+    pExternalSemaphoreProperties->externalSemaphoreFeatures = 0x3;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY,
+                                                  uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY,
+                                                  uint32_t groupCountZ) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplate(VkDevice device,
+                                                                     const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+                                                                     const VkAllocationCallbacks* pAllocator,
+                                                                     VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
+    unique_lock_t lock(global_lock);
+    *pDescriptorUpdateTemplate = (VkDescriptorUpdateTemplate)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplate(VkDevice device,
+                                                                  VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+                                                                  const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet,
+                                                                  VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+                                                                  const void* pData) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+                                                                VkDescriptorSetLayoutSupport* pSupport) {
+    if (pSupport) {
+        pSupport->supported = VK_TRUE;
+    }
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversion(VkDevice device,
+                                                                   const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+                                                                   const VkAllocationCallbacks* pAllocator,
+                                                                   VkSamplerYcbcrConversion* pYcbcrConversion) {
+    unique_lock_t lock(global_lock);
+    *pYcbcrConversion = (VkSamplerYcbcrConversion)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
+                                                                const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR void VKAPI_CALL ResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
+    VkDeviceAddress address = 0;
+    auto d_iter = buffer_map.find(device);
+    if (d_iter != buffer_map.end()) {
+        auto iter = d_iter->second.find(pInfo->buffer);
+        if (iter != d_iter->second.end()) {
+            address = iter->second.address;
+        }
+    }
+    return address;
+}
+static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddress(VkDevice device,
+                                                                          const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                       VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+                                                       uint32_t stride) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                              VkBuffer countBuffer, VkDeviceSize countBufferOffset,
+                                                              uint32_t maxDrawCount, uint32_t stride) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo,
+                                                        const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
+    unique_lock_t lock(global_lock);
+    *pRenderPass = (VkRenderPass)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin,
+                                                      const VkSubpassBeginInfo* pSubpassBeginInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo,
+                                                  const VkSubpassEndInfo* pSubpassEndInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
+                                                                      VkPhysicalDeviceToolProperties* pToolProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo,
+                                                            const VkAllocationCallbacks* pAllocator,
+                                                            VkPrivateDataSlot* pPrivateDataSlot) {
+    unique_lock_t lock(global_lock);
+    *pPrivateDataSlot = (VkPrivateDataSlot)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot,
+                                                         const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
+                                                     VkPrivateDataSlot privateDataSlot, uint64_t data) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL GetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
+                                                 VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage,
+                                                     VkQueryPool queryPool, uint32_t query) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits,
+                                                   VkFence fence) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2(VkCommandBuffer commandBuffer,
+                                                        const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2(VkCommandBuffer commandBuffer,
+                                                        const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo,
+                                                                    VkMemoryRequirements2* pMemoryRequirements) {
+    // TODO: Just hard-coding reqs for now
+    pMemoryRequirements->memoryRequirements.alignment = 1;
+    pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF;
+
+    // Return a size based on the buffer size from the create info.
+    pMemoryRequirements->memoryRequirements.size = ((pInfo->pCreateInfo->size + 4095) / 4096) * 4096;
+}
+static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
+                                                                   VkMemoryRequirements2* pMemoryRequirements) {
+    pMemoryRequirements->memoryRequirements.size = GetImageSizeFromCreateInfo(pInfo->pCreateInfo);
+    pMemoryRequirements->memoryRequirements.alignment = 1;
+    // Here we hard-code that the memory type at index 3 doesn't support this image.
+    pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF & ~(0x1 << 3);
+}
+static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirements(
+    VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount,
+    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event,
+                                               const VkDependencyInfo* pDependencyInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents,
+                                                 const VkDependencyInfo* pDependencyInfos) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdEndRendering(VkCommandBuffer commandBuffer) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount,
+                                                          const VkViewport* pViewports) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount,
+                                                         const VkRect2D* pScissors) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount,
+                                                        const VkBuffer* pBuffers, const VkDeviceSize* pOffsets,
+                                                        const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp,
+                                                  VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL MapMemory2(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData) {
+    return MapMemory2KHR(device, pMemoryMapInfo, ppData);
+}
+static VKAPI_ATTR VkResult VKAPI_CALL UnmapMemory2(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo) {
+    return UnmapMemory2KHR(device, pMemoryUnmapInfo);
+}
+static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSubresourceLayout(VkDevice device, const VkDeviceImageSubresourceInfo* pInfo,
+                                                                  VkSubresourceLayout2* pLayout) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2(VkDevice device, VkImage image,
+                                                             const VkImageSubresource2* pSubresource,
+                                                             VkSubresourceLayout2* pLayout) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToImage(VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToMemory(VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToImage(VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL TransitionImageLayout(VkDevice device, uint32_t transitionCount,
+                                                            const VkHostImageLayoutTransitionInfo* pTransitions) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
+                                                       VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount,
+                                                       const VkWriteDescriptorSet* pDescriptorWrites) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplate(VkCommandBuffer commandBuffer,
+                                                                   VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+                                                                   VkPipelineLayout layout, uint32_t set, const void* pData) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets2(VkCommandBuffer commandBuffer,
+                                                         const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdPushConstants2(VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet2(VkCommandBuffer commandBuffer,
+                                                        const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplate2(
+    VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetLineStipple(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
+                                                    uint16_t lineStipplePattern) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer2(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                      VkDeviceSize size, VkIndexType indexType) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL GetRenderingAreaGranularity(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo,
+                                                              VkExtent2D* pGranularity) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingAttachmentLocations(VkCommandBuffer commandBuffer,
+                                                                     const VkRenderingAttachmentLocationInfo* pLocationInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingInputAttachmentIndices(
+    VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
+                                                    const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
+                                                                         VkSurfaceKHR surface, VkBool32* pSupported) {
+    // Currently say that all surface/queue combos are supported
+    *pSupported = VK_TRUE;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+                                                                              VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
+    // In general just say max supported is available for requested surface
+    pSurfaceCapabilities->minImageCount = 1;
+    pSurfaceCapabilities->maxImageCount = 0;
+    pSurfaceCapabilities->currentExtent.width = 0xFFFFFFFF;
+    pSurfaceCapabilities->currentExtent.height = 0xFFFFFFFF;
+    pSurfaceCapabilities->minImageExtent.width = 1;
+    pSurfaceCapabilities->minImageExtent.height = 1;
+    pSurfaceCapabilities->maxImageExtent.width = 0xFFFF;
+    pSurfaceCapabilities->maxImageExtent.height = 0xFFFF;
+    pSurfaceCapabilities->maxImageArrayLayers = 128;
+    pSurfaceCapabilities->supportedTransforms =
+        VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR | VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR | VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR |
+        VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR | VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR |
+        VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR | VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR |
+        VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR | VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR;
+    pSurfaceCapabilities->currentTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
+    pSurfaceCapabilities->supportedCompositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR | VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR |
+                                                    VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR | VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
+    pSurfaceCapabilities->supportedUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+                                                VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT |
+                                                VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
+                                                VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+                                                                         uint32_t* pSurfaceFormatCount,
+                                                                         VkSurfaceFormatKHR* pSurfaceFormats) {
+    // Currently always say that RGBA8 & BGRA8 are supported
+    if (!pSurfaceFormats) {
+        *pSurfaceFormatCount = 2;
+    } else {
+        if (*pSurfaceFormatCount >= 2) {
+            pSurfaceFormats[1].format = VK_FORMAT_R8G8B8A8_UNORM;
+            pSurfaceFormats[1].colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
+        }
+        if (*pSurfaceFormatCount >= 1) {
+            pSurfaceFormats[0].format = VK_FORMAT_B8G8R8A8_UNORM;
+            pSurfaceFormats[0].colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
+        }
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+                                                                              uint32_t* pPresentModeCount,
+                                                                              VkPresentModeKHR* pPresentModes) {
+    // Currently always say that all present modes are supported
+    if (!pPresentModes) {
+        *pPresentModeCount = 6;
+    } else {
+        if (*pPresentModeCount >= 6) pPresentModes[5] = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR;
+        if (*pPresentModeCount >= 5) pPresentModes[4] = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR;
+        if (*pPresentModeCount >= 4) pPresentModes[3] = VK_PRESENT_MODE_FIFO_RELAXED_KHR;
+        if (*pPresentModeCount >= 3) pPresentModes[2] = VK_PRESENT_MODE_FIFO_KHR;
+        if (*pPresentModeCount >= 2) pPresentModes[1] = VK_PRESENT_MODE_MAILBOX_KHR;
+        if (*pPresentModeCount >= 1) pPresentModes[0] = VK_PRESENT_MODE_IMMEDIATE_KHR;
+        *pPresentModeCount = *pPresentModeCount < 6 ? *pPresentModeCount : 6;
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo,
+                                                         const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) {
+    unique_lock_t lock(global_lock);
+    *pSwapchain = (VkSwapchainKHR)global_unique_handle++;
+    for (uint32_t i = 0; i < icd_swapchain_image_count; ++i) {
+        swapchain_image_map[*pSwapchain][i] = (VkImage)global_unique_handle++;
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
+                                                      const VkAllocationCallbacks* pAllocator) {
+    unique_lock_t lock(global_lock);
+    swapchain_image_map.clear();
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain,
+                                                            uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) {
+    if (!pSwapchainImages) {
+        *pSwapchainImageCount = icd_swapchain_image_count;
+    } else {
+        unique_lock_t lock(global_lock);
+        for (uint32_t img_i = 0; img_i < (std::min)(*pSwapchainImageCount, icd_swapchain_image_count); ++img_i) {
+            pSwapchainImages[img_i] = swapchain_image_map.at(swapchain)[img_i];
+        }
+
+        if (*pSwapchainImageCount < icd_swapchain_image_count)
+            return VK_INCOMPLETE;
+        else if (*pSwapchainImageCount > icd_swapchain_image_count)
+            *pSwapchainImageCount = icd_swapchain_image_count;
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout,
+                                                          VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) {
+    *pImageIndex = 0;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL
+GetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface,
+                                                                           VkDeviceGroupPresentModeFlagsKHR* pModes) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+                                                                            uint32_t* pRectCount, VkRect2D* pRects) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo,
+                                                           uint32_t* pImageIndex) {
+    *pImageIndex = 0;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,
+                                                                            uint32_t* pPropertyCount,
+                                                                            VkDisplayPropertiesKHR* pProperties) {
+    if (!pProperties) {
+        *pPropertyCount = 1;
+    } else {
+        unique_lock_t lock(global_lock);
+        pProperties[0].display = (VkDisplayKHR)global_unique_handle++;
+        display_map[physicalDevice].insert(pProperties[0].display);
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice,
+                                                                                 uint32_t* pPropertyCount,
+                                                                                 VkDisplayPlanePropertiesKHR* pProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex,
+                                                                          uint32_t* pDisplayCount, VkDisplayKHR* pDisplays) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
+                                                                  uint32_t* pPropertyCount,
+                                                                  VkDisplayModePropertiesKHR* pProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
+                                                           const VkDisplayModeCreateInfoKHR* pCreateInfo,
+                                                           const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) {
+    unique_lock_t lock(global_lock);
+    *pMode = (VkDisplayModeKHR)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode,
+                                                                     uint32_t planeIndex,
+                                                                     VkDisplayPlaneCapabilitiesKHR* pCapabilities) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR(VkInstance instance,
+                                                                   const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
+                                                                   const VkAllocationCallbacks* pAllocator,
+                                                                   VkSurfaceKHR* pSurface) {
+    unique_lock_t lock(global_lock);
+    *pSurface = (VkSurfaceKHR)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount,
+                                                                const VkSwapchainCreateInfoKHR* pCreateInfos,
+                                                                const VkAllocationCallbacks* pAllocator,
+                                                                VkSwapchainKHR* pSwapchains) {
+    unique_lock_t lock(global_lock);
+    for (uint32_t i = 0; i < swapchainCount; ++i) {
+        pSwapchains[i] = (VkSwapchainKHR)global_unique_handle++;
+    }
+    return VK_SUCCESS;
+}
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+static VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
+                                                           const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    unique_lock_t lock(global_lock);
+    *pSurface = (VkSurfaceKHR)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                                  uint32_t queueFamilyIndex, Display* dpy,
+                                                                                  VisualID visualID) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_XLIB_KHR */
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+static VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
+                                                          const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    unique_lock_t lock(global_lock);
+    *pSurface = (VkSurfaceKHR)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                                 uint32_t queueFamilyIndex,
+                                                                                 xcb_connection_t* connection,
+                                                                                 xcb_visualid_t visual_id) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_XCB_KHR */
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+static VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
+                                                              const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    unique_lock_t lock(global_lock);
+    *pSurface = (VkSurfaceKHR)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                                     uint32_t queueFamilyIndex,
+                                                                                     struct wl_display* display) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_WAYLAND_KHR */
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+static VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+                                                              const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    unique_lock_t lock(global_lock);
+    *pSurface = (VkSurfaceKHR)global_unique_handle++;
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_ANDROID_KHR */
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+static VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
+                                                            const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    unique_lock_t lock(global_lock);
+    *pSurface = (VkSurfaceKHR)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                                   uint32_t queueFamilyIndex) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_WIN32_KHR */
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice,
+                                                                            const VkVideoProfileInfoKHR* pVideoProfile,
+                                                                            VkVideoCapabilitiesKHR* pCapabilities) {
+    return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoFormatPropertiesKHR(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo,
+    uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties) {
+    return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionKHR(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo,
+                                                            const VkAllocationCallbacks* pAllocator,
+                                                            VkVideoSessionKHR* pVideoSession) {
+    unique_lock_t lock(global_lock);
+    *pVideoSession = (VkVideoSessionKHR)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession,
+                                                         const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL
+GetVideoSessionMemoryRequirementsKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount,
+                                     VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements) {
+    if (!pMemoryRequirements) {
+        *pMemoryRequirementsCount = 1;
+    } else {
+        // arbitrary
+        pMemoryRequirements[0].memoryBindIndex = 0;
+        pMemoryRequirements[0].memoryRequirements.size = 4096;
+        pMemoryRequirements[0].memoryRequirements.alignment = 1;
+        pMemoryRequirements[0].memoryRequirements.memoryTypeBits = 0xFFFF;
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL BindVideoSessionMemoryKHR(VkDevice device, VkVideoSessionKHR videoSession,
+                                                                uint32_t bindSessionMemoryInfoCount,
+                                                                const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionParametersKHR(VkDevice device,
+                                                                      const VkVideoSessionParametersCreateInfoKHR* pCreateInfo,
+                                                                      const VkAllocationCallbacks* pAllocator,
+                                                                      VkVideoSessionParametersKHR* pVideoSessionParameters) {
+    unique_lock_t lock(global_lock);
+    *pVideoSessionParameters = (VkVideoSessionParametersKHR)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL UpdateVideoSessionParametersKHR(VkDevice device,
+                                                                      VkVideoSessionParametersKHR videoSessionParameters,
+                                                                      const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionParametersKHR(VkDevice device,
+                                                                   VkVideoSessionParametersKHR videoSessionParameters,
+                                                                   const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer,
+                                                         const VkVideoBeginCodingInfoKHR* pBeginInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdEndVideoCodingKHR(VkCommandBuffer commandBuffer,
+                                                       const VkVideoEndCodingInfoKHR* pEndCodingInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdControlVideoCodingKHR(VkCommandBuffer commandBuffer,
+                                                           const VkVideoCodingControlInfoKHR* pCodingControlInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdEndRenderingKHR(VkCommandBuffer commandBuffer) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice,
+                                                                VkPhysicalDeviceFeatures2* pFeatures) {
+    GetPhysicalDeviceFeatures(physicalDevice, &pFeatures->features);
+    uint32_t num_bools = 0;  // Count number of VkBool32s in extension structs
+    VkBool32* feat_bools = nullptr;
+    auto vk_1_1_features = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan11Features>(pFeatures->pNext);
+    if (vk_1_1_features) {
+        vk_1_1_features->protectedMemory = VK_TRUE;
+    }
+    auto vk_1_3_features = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan13Features>(pFeatures->pNext);
+    if (vk_1_3_features) {
+        vk_1_3_features->synchronization2 = VK_TRUE;
+    }
+    auto prot_features = lvl_find_mod_in_chain<VkPhysicalDeviceProtectedMemoryFeatures>(pFeatures->pNext);
+    if (prot_features) {
+        prot_features->protectedMemory = VK_TRUE;
+    }
+    auto sync2_features = lvl_find_mod_in_chain<VkPhysicalDeviceSynchronization2FeaturesKHR>(pFeatures->pNext);
+    if (sync2_features) {
+        sync2_features->synchronization2 = VK_TRUE;
+    }
+    auto video_maintenance1_features = lvl_find_mod_in_chain<VkPhysicalDeviceVideoMaintenance1FeaturesKHR>(pFeatures->pNext);
+    if (video_maintenance1_features) {
+        video_maintenance1_features->videoMaintenance1 = VK_TRUE;
+    }
+    const auto* desc_idx_features = lvl_find_in_chain<VkPhysicalDeviceDescriptorIndexingFeaturesEXT>(pFeatures->pNext);
+    if (desc_idx_features) {
+        const auto bool_size = sizeof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT) -
+                               offsetof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT, shaderInputAttachmentArrayDynamicIndexing);
+        num_bools = bool_size / sizeof(VkBool32);
+        feat_bools = (VkBool32*)&desc_idx_features->shaderInputAttachmentArrayDynamicIndexing;
+        SetBoolArrayTrue(feat_bools, num_bools);
+    }
+    const auto* blendop_features = lvl_find_in_chain<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(pFeatures->pNext);
+    if (blendop_features) {
+        const auto bool_size = sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT) -
+                               offsetof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, advancedBlendCoherentOperations);
+        num_bools = bool_size / sizeof(VkBool32);
+        feat_bools = (VkBool32*)&blendop_features->advancedBlendCoherentOperations;
+        SetBoolArrayTrue(feat_bools, num_bools);
+    }
+    const auto* host_image_copy_features = lvl_find_in_chain<VkPhysicalDeviceHostImageCopyFeaturesEXT>(pFeatures->pNext);
+    if (host_image_copy_features) {
+        feat_bools = (VkBool32*)&host_image_copy_features->hostImageCopy;
+        SetBoolArrayTrue(feat_bools, 1);
+    }
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,
+                                                                  VkPhysicalDeviceProperties2* pProperties) {
+    // The only value that need to be set are those the Profile layer can't set
+    // see https://github.com/KhronosGroup/Vulkan-Profiles/issues/352
+    // All values set are arbitrary
+    GetPhysicalDeviceProperties(physicalDevice, &pProperties->properties);
+
+    auto* props_11 = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan11Properties>(pProperties->pNext);
+    if (props_11) {
+        props_11->protectedNoFault = VK_FALSE;
+    }
+
+    auto* props_12 = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan12Properties>(pProperties->pNext);
+    if (props_12) {
+        props_12->denormBehaviorIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL;
+        props_12->roundingModeIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL;
+    }
+
+    auto* props_13 = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan13Properties>(pProperties->pNext);
+    if (props_13) {
+        props_13->storageTexelBufferOffsetSingleTexelAlignment = VK_TRUE;
+        props_13->uniformTexelBufferOffsetSingleTexelAlignment = VK_TRUE;
+        props_13->storageTexelBufferOffsetAlignmentBytes = 16;
+        props_13->uniformTexelBufferOffsetAlignmentBytes = 16;
+    }
+
+    auto* protected_memory_props = lvl_find_mod_in_chain<VkPhysicalDeviceProtectedMemoryProperties>(pProperties->pNext);
+    if (protected_memory_props) {
+        protected_memory_props->protectedNoFault = VK_FALSE;
+    }
+
+    auto* float_controls_props = lvl_find_mod_in_chain<VkPhysicalDeviceFloatControlsProperties>(pProperties->pNext);
+    if (float_controls_props) {
+        float_controls_props->denormBehaviorIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL;
+        float_controls_props->roundingModeIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL;
+    }
+
+    auto* conservative_raster_props =
+        lvl_find_mod_in_chain<VkPhysicalDeviceConservativeRasterizationPropertiesEXT>(pProperties->pNext);
+    if (conservative_raster_props) {
+        conservative_raster_props->primitiveOverestimationSize = 0.00195313f;
+        conservative_raster_props->conservativePointAndLineRasterization = VK_TRUE;
+        conservative_raster_props->degenerateTrianglesRasterized = VK_TRUE;
+        conservative_raster_props->degenerateLinesRasterized = VK_TRUE;
+    }
+
+    auto* rt_pipeline_props = lvl_find_mod_in_chain<VkPhysicalDeviceRayTracingPipelinePropertiesKHR>(pProperties->pNext);
+    if (rt_pipeline_props) {
+        rt_pipeline_props->shaderGroupHandleSize = 32;
+        rt_pipeline_props->shaderGroupBaseAlignment = 64;
+        rt_pipeline_props->shaderGroupHandleCaptureReplaySize = 32;
+    }
+
+    auto* rt_pipeline_nv_props = lvl_find_mod_in_chain<VkPhysicalDeviceRayTracingPropertiesNV>(pProperties->pNext);
+    if (rt_pipeline_nv_props) {
+        rt_pipeline_nv_props->shaderGroupHandleSize = 32;
+        rt_pipeline_nv_props->shaderGroupBaseAlignment = 64;
+    }
+
+    auto* texel_buffer_props = lvl_find_mod_in_chain<VkPhysicalDeviceTexelBufferAlignmentProperties>(pProperties->pNext);
+    if (texel_buffer_props) {
+        texel_buffer_props->storageTexelBufferOffsetSingleTexelAlignment = VK_TRUE;
+        texel_buffer_props->uniformTexelBufferOffsetSingleTexelAlignment = VK_TRUE;
+        texel_buffer_props->storageTexelBufferOffsetAlignmentBytes = 16;
+        texel_buffer_props->uniformTexelBufferOffsetAlignmentBytes = 16;
+    }
+
+    auto* descriptor_buffer_props = lvl_find_mod_in_chain<VkPhysicalDeviceDescriptorBufferPropertiesEXT>(pProperties->pNext);
+    if (descriptor_buffer_props) {
+        descriptor_buffer_props->combinedImageSamplerDescriptorSingleArray = VK_TRUE;
+        descriptor_buffer_props->bufferlessPushDescriptors = VK_TRUE;
+        descriptor_buffer_props->allowSamplerImageViewPostSubmitCreation = VK_TRUE;
+        descriptor_buffer_props->descriptorBufferOffsetAlignment = 4;
+    }
+
+    auto* mesh_shader_props = lvl_find_mod_in_chain<VkPhysicalDeviceMeshShaderPropertiesEXT>(pProperties->pNext);
+    if (mesh_shader_props) {
+        mesh_shader_props->meshOutputPerVertexGranularity = 32;
+        mesh_shader_props->meshOutputPerPrimitiveGranularity = 32;
+        mesh_shader_props->prefersLocalInvocationVertexOutput = VK_TRUE;
+        mesh_shader_props->prefersLocalInvocationPrimitiveOutput = VK_TRUE;
+        mesh_shader_props->prefersCompactVertexOutput = VK_TRUE;
+        mesh_shader_props->prefersCompactPrimitiveOutput = VK_TRUE;
+    }
+
+    auto* fragment_density_map2_props = lvl_find_mod_in_chain<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT>(pProperties->pNext);
+    if (fragment_density_map2_props) {
+        fragment_density_map2_props->subsampledLoads = VK_FALSE;
+        fragment_density_map2_props->subsampledCoarseReconstructionEarlyAccess = VK_FALSE;
+        fragment_density_map2_props->maxSubsampledArrayLayers = 2;
+        fragment_density_map2_props->maxDescriptorSetSubsampledSamplers = 1;
+    }
+
+    auto* maintenance3_props = lvl_find_mod_in_chain<VkPhysicalDeviceMaintenance3Properties>(pProperties->pNext);
+    if (maintenance3_props) {
+        maintenance3_props->maxMemoryAllocationSize = 1073741824;
+        maintenance3_props->maxPerSetDescriptors = 1024;
+    }
+
+    const uint32_t num_copy_layouts = 5;
+    const VkImageLayout HostCopyLayouts[]{
+        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,        VK_IMAGE_LAYOUT_GENERAL,
+        VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL,
+        VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL,
+    };
+
+    auto* host_image_copy_props = lvl_find_mod_in_chain<VkPhysicalDeviceHostImageCopyPropertiesEXT>(pProperties->pNext);
+    if (host_image_copy_props) {
+        if (host_image_copy_props->pCopyDstLayouts == nullptr)
+            host_image_copy_props->copyDstLayoutCount = num_copy_layouts;
+        else {
+            uint32_t num_layouts = (std::min)(host_image_copy_props->copyDstLayoutCount, num_copy_layouts);
+            for (uint32_t i = 0; i < num_layouts; i++) {
+                host_image_copy_props->pCopyDstLayouts[i] = HostCopyLayouts[i];
+            }
+        }
+        if (host_image_copy_props->pCopySrcLayouts == nullptr)
+            host_image_copy_props->copySrcLayoutCount = num_copy_layouts;
+        else {
+            uint32_t num_layouts = (std::min)(host_image_copy_props->copySrcLayoutCount, num_copy_layouts);
+            for (uint32_t i = 0; i < num_layouts; i++) {
+                host_image_copy_props->pCopySrcLayouts[i] = HostCopyLayouts[i];
+            }
+        }
+    }
+
+    auto* driver_properties = lvl_find_mod_in_chain<VkPhysicalDeviceDriverProperties>(pProperties->pNext);
+    if (driver_properties) {
+        std::strncpy(driver_properties->driverName, "Vulkan Mock Device", VK_MAX_DRIVER_NAME_SIZE);
+#if defined(GIT_BRANCH_NAME) && defined(GIT_TAG_INFO)
+        std::strncpy(driver_properties->driverInfo, "Branch: " GIT_BRANCH_NAME " Tag Info: " GIT_TAG_INFO, VK_MAX_DRIVER_INFO_SIZE);
+#else
+        std::strncpy(driver_properties->driverInfo, "Branch: --unknown-- Tag Info: --unknown--", VK_MAX_DRIVER_INFO_SIZE);
+#endif
+    }
+
+    auto* layered_properties = lvl_find_mod_in_chain<VkPhysicalDeviceLayeredApiPropertiesListKHR>(pProperties->pNext);
+    if (layered_properties) {
+        layered_properties->layeredApiCount = 1;
+        if (layered_properties->pLayeredApis) {
+            layered_properties->pLayeredApis[0] =
+                VkPhysicalDeviceLayeredApiPropertiesKHR{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR, nullptr,
+                                                        0xba5eba11, 0xf005ba11, VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR};
+            std::strncpy(layered_properties->pLayeredApis[0].deviceName, "Fake Driver", VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
+        }
+    }
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format,
+                                                                        VkFormatProperties2* pFormatProperties) {
+    GetPhysicalDeviceFormatProperties(physicalDevice, format, &pFormatProperties->formatProperties);
+    VkFormatProperties3KHR* props_3 = lvl_find_mod_in_chain<VkFormatProperties3KHR>(pFormatProperties->pNext);
+    if (props_3) {
+        props_3->linearTilingFeatures = pFormatProperties->formatProperties.linearTilingFeatures;
+        props_3->optimalTilingFeatures = pFormatProperties->formatProperties.optimalTilingFeatures;
+        props_3->bufferFeatures = pFormatProperties->formatProperties.bufferFeatures;
+        props_3->optimalTilingFeatures |= VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT;
+    }
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+    VkImageFormatProperties2* pImageFormatProperties) {
+    auto* external_image_prop = lvl_find_mod_in_chain<VkExternalImageFormatProperties>(pImageFormatProperties->pNext);
+    auto* external_image_format = lvl_find_in_chain<VkPhysicalDeviceExternalImageFormatInfo>(pImageFormatInfo->pNext);
+    if (external_image_prop && external_image_format) {
+        external_image_prop->externalMemoryProperties.externalMemoryFeatures =
+            VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
+        external_image_prop->externalMemoryProperties.compatibleHandleTypes = external_image_format->handleType;
+    }
+
+    GetPhysicalDeviceImageFormatProperties(physicalDevice, pImageFormatInfo->format, pImageFormatInfo->type,
+                                           pImageFormatInfo->tiling, pImageFormatInfo->usage, pImageFormatInfo->flags,
+                                           &pImageFormatProperties->imageFormatProperties);
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice,
+                                                                             uint32_t* pQueueFamilyPropertyCount,
+                                                                             VkQueueFamilyProperties2* pQueueFamilyProperties) {
+    if (pQueueFamilyProperties) {
+        if (*pQueueFamilyPropertyCount >= 1) {
+            auto props = &pQueueFamilyProperties[0].queueFamilyProperties;
+            props->queueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT | VK_QUEUE_SPARSE_BINDING_BIT |
+                                VK_QUEUE_PROTECTED_BIT;
+            props->queueCount = 1;
+            props->timestampValidBits = 16;
+            props->minImageTransferGranularity = {1, 1, 1};
+        }
+        if (*pQueueFamilyPropertyCount >= 2) {
+            auto props = &pQueueFamilyProperties[1].queueFamilyProperties;
+            props->queueFlags = VK_QUEUE_TRANSFER_BIT | VK_QUEUE_PROTECTED_BIT | VK_QUEUE_VIDEO_DECODE_BIT_KHR;
+            props->queueCount = 1;
+            props->timestampValidBits = 16;
+            props->minImageTransferGranularity = {1, 1, 1};
+
+            auto status_query_props =
+                lvl_find_mod_in_chain<VkQueueFamilyQueryResultStatusPropertiesKHR>(pQueueFamilyProperties[1].pNext);
+            if (status_query_props) {
+                status_query_props->queryResultStatusSupport = VK_TRUE;
+            }
+            auto video_props = lvl_find_mod_in_chain<VkQueueFamilyVideoPropertiesKHR>(pQueueFamilyProperties[1].pNext);
+            if (video_props) {
+                video_props->videoCodecOperations = VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR |
+                                                    VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR |
+                                                    VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR;
+            }
+        }
+        if (*pQueueFamilyPropertyCount >= 3) {
+            auto props = &pQueueFamilyProperties[2].queueFamilyProperties;
+            props->queueFlags = VK_QUEUE_TRANSFER_BIT | VK_QUEUE_PROTECTED_BIT | VK_QUEUE_VIDEO_ENCODE_BIT_KHR;
+            props->queueCount = 1;
+            props->timestampValidBits = 16;
+            props->minImageTransferGranularity = {1, 1, 1};
+
+            auto status_query_props =
+                lvl_find_mod_in_chain<VkQueueFamilyQueryResultStatusPropertiesKHR>(pQueueFamilyProperties[2].pNext);
+            if (status_query_props) {
+                status_query_props->queryResultStatusSupport = VK_TRUE;
+            }
+            auto video_props = lvl_find_mod_in_chain<VkQueueFamilyVideoPropertiesKHR>(pQueueFamilyProperties[2].pNext);
+            if (video_props) {
+                video_props->videoCodecOperations = VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR |
+                                                    VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR |
+                                                    VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR;
+            }
+        }
+        if (*pQueueFamilyPropertyCount > 3) {
+            *pQueueFamilyPropertyCount = 3;
+        }
+    } else {
+        *pQueueFamilyPropertyCount = 3;
+    }
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice,
+                                                                        VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
+    GetPhysicalDeviceMemoryProperties(physicalDevice, &pMemoryProperties->memoryProperties);
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount,
+    VkSparseImageFormatProperties2* pProperties) {
+    if (pPropertyCount && pProperties) {
+        GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, pFormatInfo->format, pFormatInfo->type, pFormatInfo->samples,
+                                                     pFormatInfo->usage, pFormatInfo->tiling, pPropertyCount,
+                                                     &pProperties->properties);
+    } else {
+        GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, pFormatInfo->format, pFormatInfo->type, pFormatInfo->samples,
+                                                     pFormatInfo->usage, pFormatInfo->tiling, pPropertyCount, nullptr);
+    }
+}
+static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex,
+                                                                      uint32_t localDeviceIndex, uint32_t remoteDeviceIndex,
+                                                                      VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY,
+                                                     uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY,
+                                                     uint32_t groupCountZ) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHR(
+    VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
+    if (!pPhysicalDeviceGroupProperties) {
+        *pPhysicalDeviceGroupCount = 1;
+    } else {
+        // arbitrary
+        pPhysicalDeviceGroupProperties->physicalDeviceCount = 1;
+        pPhysicalDeviceGroupProperties->physicalDevices[0] = physical_device_map.at(instance)[0];
+        pPhysicalDeviceGroupProperties->subsetAllocation = VK_FALSE;
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+    VkExternalBufferProperties* pExternalBufferProperties) {
+    GetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+}
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR(VkDevice device,
+                                                              const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+                                                              HANDLE* pHandle) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL
+GetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle,
+                                  VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) {
+    pMemoryWin32HandleProperties->memoryTypeBits = 0xFFFF;
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_WIN32_KHR */
+static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) {
+    *pFd = 1;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType,
+                                                               int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+    VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
+    GetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
+}
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+static VKAPI_ATTR VkResult VKAPI_CALL
+ImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR(VkDevice device,
+                                                                 const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+                                                                 HANDLE* pHandle) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_WIN32_KHR */
+static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR(VkDevice device,
+                                                           const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
+                                                          VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount,
+                                                          const VkWriteDescriptorSet* pDescriptorWrites) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer,
+                                                                      VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+                                                                      VkPipelineLayout layout, uint32_t set, const void* pData) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(VkDevice device,
+                                                                        const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+                                                                        const VkAllocationCallbacks* pAllocator,
+                                                                        VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
+    unique_lock_t lock(global_lock);
+    *pDescriptorUpdateTemplate = (VkDescriptorUpdateTemplate)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(VkDevice device,
+                                                                     VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+                                                                     const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet,
+                                                                     VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+                                                                     const void* pData) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo,
+                                                           const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
+    unique_lock_t lock(global_lock);
+    *pRenderPass = (VkRenderPass)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,
+                                                         const VkRenderPassBeginInfo* pRenderPassBegin,
+                                                         const VkSubpassBeginInfo* pSubpassBeginInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo,
+                                                     const VkSubpassEndInfo* pSubpassEndInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+    VkExternalFenceProperties* pExternalFenceProperties) {
+    GetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+}
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+static VKAPI_ATTR VkResult VKAPI_CALL
+ImportFenceWin32HandleKHR(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR(VkDevice device,
+                                                             const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+                                                             HANDLE* pHandle) {
+    *pHandle = (HANDLE)0x12345678;
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_WIN32_KHR */
+static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) {
+    *pFd = 0x42;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
+    VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters,
+    VkPerformanceCounterDescriptionKHR* pCounterDescriptions) {
+    if (!pCounters) {
+        *pCounterCount = 3;
+    } else {
+        if (*pCounterCount == 0) {
+            return VK_INCOMPLETE;
+        }
+        // arbitrary
+        pCounters[0].unit = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR;
+        pCounters[0].scope = VK_QUERY_SCOPE_COMMAND_BUFFER_KHR;
+        pCounters[0].storage = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR;
+        pCounters[0].uuid[0] = 0x01;
+        if (*pCounterCount == 1) {
+            return VK_INCOMPLETE;
+        }
+        pCounters[1].unit = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR;
+        pCounters[1].scope = VK_QUERY_SCOPE_RENDER_PASS_KHR;
+        pCounters[1].storage = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR;
+        pCounters[1].uuid[0] = 0x02;
+        if (*pCounterCount == 2) {
+            return VK_INCOMPLETE;
+        }
+        pCounters[2].unit = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR;
+        pCounters[2].scope = VK_QUERY_SCOPE_COMMAND_KHR;
+        pCounters[2].storage = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR;
+        pCounters[2].uuid[0] = 0x03;
+        *pCounterCount = 3;
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
+    VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses) {
+    if (pNumPasses) {
+        // arbitrary
+        *pNumPasses = 1;
+    }
+}
+static VKAPI_ATTR VkResult VKAPI_CALL AcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL ReleaseProfilingLockKHR(VkDevice device) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice,
+                                                                               const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+                                                                               VkSurfaceCapabilities2KHR* pSurfaceCapabilities) {
+    GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, pSurfaceInfo->surface, &pSurfaceCapabilities->surfaceCapabilities);
+
+    auto* present_mode_compatibility = lvl_find_mod_in_chain<VkSurfacePresentModeCompatibilityEXT>(pSurfaceCapabilities->pNext);
+    if (present_mode_compatibility) {
+        if (!present_mode_compatibility->pPresentModes) {
+            present_mode_compatibility->presentModeCount = 3;
+        } else {
+            // arbitrary
+            present_mode_compatibility->pPresentModes[0] = VK_PRESENT_MODE_IMMEDIATE_KHR;
+            present_mode_compatibility->pPresentModes[1] = VK_PRESENT_MODE_FIFO_KHR;
+            present_mode_compatibility->pPresentModes[2] = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR;
+        }
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice,
+                                                                          const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+                                                                          uint32_t* pSurfaceFormatCount,
+                                                                          VkSurfaceFormat2KHR* pSurfaceFormats) {
+    // Currently always say that RGBA8 & BGRA8 are supported
+    if (!pSurfaceFormats) {
+        *pSurfaceFormatCount = 2;
+    } else {
+        if (*pSurfaceFormatCount >= 2) {
+            pSurfaceFormats[1].pNext = nullptr;
+            pSurfaceFormats[1].surfaceFormat.format = VK_FORMAT_R8G8B8A8_UNORM;
+            pSurfaceFormats[1].surfaceFormat.colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
+        }
+        if (*pSurfaceFormatCount >= 1) {
+            pSurfaceFormats[1].pNext = nullptr;
+            pSurfaceFormats[0].surfaceFormat.format = VK_FORMAT_B8G8R8A8_UNORM;
+            pSurfaceFormats[0].surfaceFormat.colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
+        }
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice,
+                                                                             uint32_t* pPropertyCount,
+                                                                             VkDisplayProperties2KHR* pProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice,
+                                                                                  uint32_t* pPropertyCount,
+                                                                                  VkDisplayPlaneProperties2KHR* pProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
+                                                                   uint32_t* pPropertyCount,
+                                                                   VkDisplayModeProperties2KHR* pProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice,
+                                                                      const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
+                                                                      VkDisplayPlaneCapabilities2KHR* pCapabilities) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo,
+                                                                 VkMemoryRequirements2* pMemoryRequirements) {
+    GetImageMemoryRequirements(device, pInfo->image, &pMemoryRequirements->memoryRequirements);
+}
+static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo,
+                                                                  VkMemoryRequirements2* pMemoryRequirements) {
+    GetBufferMemoryRequirements(device, pInfo->buffer, &pMemoryRequirements->memoryRequirements);
+}
+static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR(
+    VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount,
+    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
+    if (pSparseMemoryRequirementCount && pSparseMemoryRequirements) {
+        GetImageSparseMemoryRequirements(device, pInfo->image, pSparseMemoryRequirementCount,
+                                         &pSparseMemoryRequirements->memoryRequirements);
+    } else {
+        GetImageSparseMemoryRequirements(device, pInfo->image, pSparseMemoryRequirementCount, nullptr);
+    }
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversionKHR(VkDevice device,
+                                                                      const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+                                                                      const VkAllocationCallbacks* pAllocator,
+                                                                      VkSamplerYcbcrConversion* pYcbcrConversion) {
+    unique_lock_t lock(global_lock);
+    *pYcbcrConversion = (VkSamplerYcbcrConversion)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
+                                                                   const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount,
+                                                           const VkBindBufferMemoryInfo* pBindInfos) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount,
+                                                          const VkBindImageMemoryInfo* pBindInfos) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupportKHR(VkDevice device,
+                                                                   const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+                                                                   VkDescriptorSetLayoutSupport* pSupport) {
+    GetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                          VkBuffer countBuffer, VkDeviceSize countBufferOffset,
+                                                          uint32_t maxDrawCount, uint32_t stride) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                                                 VkDeviceSize offset, VkBuffer countBuffer,
+                                                                 VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+                                                                 uint32_t stride) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t* pValue) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL
+GetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount,
+                                         VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates) {
+    if (!pFragmentShadingRates) {
+        *pFragmentShadingRateCount = 1;
+    } else {
+        // arbitrary
+        pFragmentShadingRates->sampleCounts = VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT;
+        pFragmentShadingRates->fragmentSize = {8, 8};
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize,
+                                                               const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingAttachmentLocationsKHR(VkCommandBuffer commandBuffer,
+                                                                        const VkRenderingAttachmentLocationInfo* pLocationInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingInputAttachmentIndicesKHR(
+    VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL WaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId,
+                                                        uint64_t timeout) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
+    return GetBufferDeviceAddress(device, pInfo);
+}
+static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device,
+                                                                             const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks* pAllocator,
+                                                                 VkDeferredOperationKHR* pDeferredOperation) {
+    unique_lock_t lock(global_lock);
+    *pDeferredOperation = (VkDeferredOperationKHR)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation,
+                                                              const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR uint32_t VKAPI_CALL GetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL DeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo,
+                                                                         uint32_t* pExecutableCount,
+                                                                         VkPipelineExecutablePropertiesKHR* pProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableStatisticsKHR(VkDevice device,
+                                                                         const VkPipelineExecutableInfoKHR* pExecutableInfo,
+                                                                         uint32_t* pStatisticCount,
+                                                                         VkPipelineExecutableStatisticKHR* pStatistics) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableInternalRepresentationsKHR(
+    VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount,
+    VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL MapMemory2KHR(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData) {
+    return MapMemory(device, pMemoryMapInfo->memory, pMemoryMapInfo->offset, pMemoryMapInfo->size, pMemoryMapInfo->flags, ppData);
+}
+static VKAPI_ATTR VkResult VKAPI_CALL UnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo) {
+    UnmapMemory(device, pMemoryUnmapInfo->memory);
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo,
+    VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL
+GetEncodedVideoSessionParametersKHR(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo,
+                                    VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
+                                                  const VkDependencyInfo* pDependencyInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents,
+                                                    const VkDependencyInfo* pDependencyInfos) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage,
+                                                        VkQueryPool queryPool, uint32_t query) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits,
+                                                      VkFence fence) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer3KHR(VkCommandBuffer commandBuffer, const VkBindIndexBuffer3InfoKHR* pInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers3KHR(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+                                                           uint32_t bindingCount, const VkBindVertexBuffer3InfoKHR* pBindingInfos) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect2KHR(VkCommandBuffer commandBuffer, const VkDrawIndirect2InfoKHR* pInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect2KHR(VkCommandBuffer commandBuffer, const VkDrawIndirect2InfoKHR* pInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect2KHR(VkCommandBuffer commandBuffer, const VkDispatchIndirect2InfoKHR* pInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryKHR(VkCommandBuffer commandBuffer,
+                                                   const VkCopyDeviceMemoryInfoKHR* pCopyMemoryInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToImageKHR(VkCommandBuffer commandBuffer,
+                                                          const VkCopyDeviceMemoryImageInfoKHR* pCopyMemoryInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToMemoryKHR(VkCommandBuffer commandBuffer,
+                                                          const VkCopyDeviceMemoryImageInfoKHR* pCopyMemoryInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdUpdateMemoryKHR(VkCommandBuffer commandBuffer, const VkDeviceAddressRangeKHR* pDstRange,
+                                                     VkAddressCommandFlagsKHR dstFlags, VkDeviceSize dataSize, const void* pData) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdFillMemoryKHR(VkCommandBuffer commandBuffer, const VkDeviceAddressRangeKHR* pDstRange,
+                                                   VkAddressCommandFlagsKHR dstFlags, uint32_t data) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResultsToMemoryKHR(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                                                                     uint32_t firstQuery, uint32_t queryCount,
+                                                                     const VkStridedDeviceAddressRangeKHR* pDstRange,
+                                                                     VkAddressCommandFlagsKHR dstFlags,
+                                                                     VkQueryResultFlags queryResultFlags) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCount2KHR(VkCommandBuffer commandBuffer,
+                                                           const VkDrawIndirectCount2InfoKHR* pInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCount2KHR(VkCommandBuffer commandBuffer,
+                                                                  const VkDrawIndirectCount2InfoKHR* pInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBeginConditionalRendering2EXT(
+    VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfo2EXT* pConditionalRenderingBegin) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+                                                                      uint32_t bindingCount,
+                                                                      const VkBindTransformFeedbackBuffer2InfoEXT* pBindingInfos) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedback2EXT(VkCommandBuffer commandBuffer, uint32_t firstCounterRange,
+                                                                uint32_t counterRangeCount,
+                                                                const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfos) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedback2EXT(VkCommandBuffer commandBuffer, uint32_t firstCounterRange,
+                                                              uint32_t counterRangeCount,
+                                                              const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfos) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectByteCount2EXT(VkCommandBuffer commandBuffer, uint32_t instanceCount,
+                                                               uint32_t firstInstance,
+                                                               const VkBindTransformFeedbackBuffer2InfoEXT* pCounterInfo,
+                                                               uint32_t counterOffset, uint32_t vertexStride) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirect2EXT(VkCommandBuffer commandBuffer, const VkDrawIndirect2InfoKHR* pInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCount2EXT(VkCommandBuffer commandBuffer,
+                                                                    const VkDrawIndirectCount2InfoKHR* pInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdWriteMarkerToMemoryAMD(VkCommandBuffer commandBuffer, const VkMemoryMarkerInfoAMD* pInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructure2KHR(VkDevice device,
+                                                                      const VkAccelerationStructureCreateInfo2KHR* pCreateInfo,
+                                                                      const VkAllocationCallbacks* pAllocator,
+                                                                      VkAccelerationStructureKHR* pAccelerationStructure) {
+    unique_lock_t lock(global_lock);
+    *pAccelerationStructure = (VkAccelerationStructureKHR)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer,
+                                                           const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer,
+                                                           const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirect2KHR(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirementsKHR(VkDevice device,
+                                                                       const VkDeviceBufferMemoryRequirements* pInfo,
+                                                                       VkMemoryRequirements2* pMemoryRequirements) {
+    GetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements);
+}
+static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
+                                                                      VkMemoryRequirements2* pMemoryRequirements) {
+    GetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements);
+}
+static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirementsKHR(
+    VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount,
+    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                         VkDeviceSize size, VkIndexType indexType) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL GetRenderingAreaGranularityKHR(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo,
+                                                                 VkExtent2D* pGranularity) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSubresourceLayoutKHR(VkDevice device, const VkDeviceImageSubresourceInfo* pInfo,
+                                                                     VkSubresourceLayout2* pLayout) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2KHR(VkDevice device, VkImage image,
+                                                                const VkImageSubresource2* pSubresource,
+                                                                VkSubresourceLayout2* pLayout) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL WaitForPresent2KHR(VkDevice device, VkSwapchainKHR swapchain,
+                                                         const VkPresentWait2InfoKHR* pPresentWait2Info) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineBinariesKHR(VkDevice device, const VkPipelineBinaryCreateInfoKHR* pCreateInfo,
+                                                                const VkAllocationCallbacks* pAllocator,
+                                                                VkPipelineBinaryHandlesInfoKHR* pBinaries) {
+    unique_lock_t lock(global_lock);
+    if (pBinaries->pPipelineBinaries != nullptr) {
+        for (uint32_t i = 0; i < pBinaries->pipelineBinaryCount; ++i) {
+            pBinaries->pPipelineBinaries[i] = (VkPipelineBinaryKHR)global_unique_handle++;
+        }
+    } else {
+        // In this case, we need to return a return count, let's set it to 3
+        pBinaries->pipelineBinaryCount = 3;
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyPipelineBinaryKHR(VkDevice device, VkPipelineBinaryKHR pipelineBinary,
+                                                           const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineKeyKHR(VkDevice device, const VkPipelineCreateInfoKHR* pPipelineCreateInfo,
+                                                        VkPipelineBinaryKeyKHR* pPipelineKey) {
+    if (pPipelineKey != nullptr) {
+        pPipelineKey->keySize = 16;
+        std::memset(pPipelineKey->key, 0x12, pPipelineKey->keySize);
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineBinaryDataKHR(VkDevice device, const VkPipelineBinaryDataInfoKHR* pInfo,
+                                                               VkPipelineBinaryKeyKHR* pPipelineBinaryKey,
+                                                               size_t* pPipelineBinaryDataSize, void* pPipelineBinaryData) {
+    static uint32_t fake_size = 64;
+    if (pPipelineBinaryDataSize != nullptr) {
+        if (pPipelineBinaryData == nullptr) {
+            *pPipelineBinaryDataSize = fake_size;
+        } else {
+            std::memset(pPipelineBinaryData, 0xABCD, fake_size);
+        }
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL ReleaseCapturedPipelineDataKHR(VkDevice device,
+                                                                     const VkReleaseCapturedPipelineDataInfoKHR* pInfo,
+                                                                     const VkAllocationCallbacks* pAllocator) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL ReleaseSwapchainImagesKHR(VkDevice device,
+                                                                const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesKHR(
+    VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties) {
+    if (!pProperties) {
+        *pPropertyCount = 2;
+    } else {
+        // arbitrary
+        pProperties[0].MSize = 16;
+        pProperties[0].NSize = 16;
+        pProperties[0].KSize = 16;
+        pProperties[0].AType = VK_COMPONENT_TYPE_UINT32_KHR;
+        pProperties[0].BType = VK_COMPONENT_TYPE_UINT32_KHR;
+        pProperties[0].CType = VK_COMPONENT_TYPE_UINT32_KHR;
+        pProperties[0].ResultType = VK_COMPONENT_TYPE_UINT32_KHR;
+        pProperties[0].saturatingAccumulation = VK_FALSE;
+        pProperties[0].scope = VK_SCOPE_SUBGROUP_KHR;
+
+        pProperties[1] = pProperties[0];
+        pProperties[1].scope = VK_SCOPE_DEVICE_KHR;
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleKHR(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
+                                                       uint16_t lineStipplePattern) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice,
+                                                                                   uint32_t* pTimeDomainCount,
+                                                                                   VkTimeDomainKHR* pTimeDomains) {
+    if (!pTimeDomains) {
+        *pTimeDomainCount = 1;
+    } else {
+        // arbitrary
+        *pTimeDomains = VK_TIME_DOMAIN_DEVICE_KHR;
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampCount,
+                                                                 const VkCalibratedTimestampInfoKHR* pTimestampInfos,
+                                                                 uint64_t* pTimestamps, uint64_t* pMaxDeviation) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer,
+                                                            const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdPushConstants2KHR(VkCommandBuffer commandBuffer,
+                                                       const VkPushConstantsInfo* pPushConstantsInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer,
+                                                           const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplate2KHR(
+    VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetDescriptorBufferOffsets2EXT(
+    VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBufferEmbeddedSamplers2EXT(
+    VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryIndirectKHR(VkCommandBuffer commandBuffer,
+                                                           const VkCopyMemoryIndirectInfoKHR* pCopyMemoryIndirectInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToImageIndirectKHR(
+    VkCommandBuffer commandBuffer, const VkCopyMemoryToImageIndirectInfoKHR* pCopyMemoryToImageIndirectInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceFaultReportsKHR(VkDevice device, uint64_t timeout, uint32_t* pFaultCounts,
+                                                               VkDeviceFaultInfoKHR* pFaultInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceFaultDebugInfoKHR(VkDevice device, VkDeviceFaultDebugInfoKHR* pDebugInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdEndRendering2KHR(VkCommandBuffer commandBuffer,
+                                                      const VkRenderingEndInfoKHR* pRenderingEndInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(VkInstance instance,
+                                                                   const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
+                                                                   const VkAllocationCallbacks* pAllocator,
+                                                                   VkDebugReportCallbackEXT* pCallback) {
+    unique_lock_t lock(global_lock);
+    *pCallback = (VkDebugReportCallbackEXT)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback,
+                                                                const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
+                                                        VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location,
+                                                        int32_t messageCode, const char* pLayerPrefix, const char* pMessage) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(VkDevice device,
+                                                                  const VkDebugMarkerObjectNameInfoEXT* pNameInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer,
+                                                         const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer,
+                                                          const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+                                                                     uint32_t bindingCount, const VkBuffer* pBuffers,
+                                                                     const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer,
+                                                               uint32_t counterBufferCount, const VkBuffer* pCounterBuffers,
+                                                               const VkDeviceSize* pCounterBufferOffsets) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer,
+                                                             uint32_t counterBufferCount, const VkBuffer* pCounterBuffers,
+                                                             const VkDeviceSize* pCounterBufferOffsets) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query,
+                                                          VkQueryControlFlags flags, uint32_t index) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query,
+                                                        uint32_t index) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount,
+                                                              uint32_t firstInstance, VkBuffer counterBuffer,
+                                                              VkDeviceSize counterBufferOffset, uint32_t counterOffset,
+                                                              uint32_t vertexStride) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo,
+                                                        const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule) {
+    unique_lock_t lock(global_lock);
+    *pModule = (VkCuModuleNVX)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo,
+                                                          const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction) {
+    unique_lock_t lock(global_lock);
+    *pFunction = (VkCuFunctionNVX)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module,
+                                                     const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function,
+                                                       const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR uint32_t VKAPI_CALL GetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR uint64_t VKAPI_CALL GetImageViewHandle64NVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetImageViewAddressNVX(VkDevice device, VkImageView imageView,
+                                                             VkImageViewAddressPropertiesNVX* pProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceCombinedImageSamplerIndexNVX(VkDevice device, uint64_t imageViewIndex,
+                                                                            uint64_t samplerIndex) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                          VkBuffer countBuffer, VkDeviceSize countBufferOffset,
+                                                          uint32_t maxDrawCount, uint32_t stride) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                                                 VkDeviceSize offset, VkBuffer countBuffer,
+                                                                 VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+                                                                 uint32_t stride) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage,
+                                                       VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+#ifdef VK_USE_PLATFORM_GGP
+static VKAPI_ATTR VkResult VKAPI_CALL CreateStreamDescriptorSurfaceGGP(VkInstance instance,
+                                                                       const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
+                                                                       const VkAllocationCallbacks* pAllocator,
+                                                                       VkSurfaceKHR* pSurface) {
+    unique_lock_t lock(global_lock);
+    *pSurface = (VkSurfaceKHR)global_unique_handle++;
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_GGP */
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceExternalImageFormatPropertiesNV(
+    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage,
+    VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType,
+    VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory,
+                                                             VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_WIN32_KHR */
+
+#ifdef VK_USE_PLATFORM_VI_NN
+static VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo,
+                                                        const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    unique_lock_t lock(global_lock);
+    *pSurface = (VkSurfaceKHR)global_unique_handle++;
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_VI_NN */
+static VKAPI_ATTR void VKAPI_CALL CmdBeginConditionalRenderingEXT(
+    VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport,
+                                                           uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
+static VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput,
+                                                               VkDisplayKHR* pDisplay) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice,
+                                                                               VkSurfaceKHR surface,
+                                                                               VkSurfaceCapabilities2EXT* pSurfaceCapabilities) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT(VkDevice device, VkDisplayKHR display,
+                                                             const VkDisplayPowerInfoEXT* pDisplayPowerInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo,
+                                                             const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display,
+                                                              const VkDisplayEventInfoEXT* pDisplayEventInfo,
+                                                              const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
+    unique_lock_t lock(global_lock);
+    *pFence = (VkFence)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain,
+                                                             VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain,
+                                                                    VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain,
+                                                                      uint32_t* pPresentationTimingCount,
+                                                                      VkPastPresentationTimingGOOGLE* pPresentationTimings) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle,
+                                                            uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleModeEXT(VkCommandBuffer commandBuffer,
+                                                                VkDiscardRectangleModeEXT discardRectangleMode) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains,
+                                                    const VkHdrMetadataEXT* pMetadata) {
+    // Not a CREATE or DESTROY function
+}
+#ifdef VK_USE_PLATFORM_IOS_MVK
+static VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
+                                                          const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    unique_lock_t lock(global_lock);
+    *pSurface = (VkSurfaceKHR)global_unique_handle++;
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_IOS_MVK */
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+static VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
+                                                            const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    unique_lock_t lock(global_lock);
+    *pSurface = (VkSurfaceKHR)global_unique_handle++;
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_MACOS_MVK */
+static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL QueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL QueueEndDebugUtilsLabelEXT(VkQueue queue) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL QueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer,
+                                                             const VkDebugUtilsLabelEXT* pLabelInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer,
+                                                              const VkDebugUtilsLabelEXT* pLabelInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT(VkInstance instance,
+                                                                   const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
+                                                                   const VkAllocationCallbacks* pAllocator,
+                                                                   VkDebugUtilsMessengerEXT* pMessenger) {
+    unique_lock_t lock(global_lock);
+    *pMessenger = (VkDebugUtilsMessengerEXT)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger,
+                                                                const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR void VKAPI_CALL SubmitDebugUtilsMessageEXT(VkInstance instance,
+                                                             VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+                                                             VkDebugUtilsMessageTypeFlagsEXT messageTypes,
+                                                             const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) {
+    // Not a CREATE or DESTROY function
+}
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+static VKAPI_ATTR VkResult VKAPI_CALL GetAndroidHardwareBufferPropertiesANDROID(
+    VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties) {
+    pProperties->allocationSize = 65536;
+    pProperties->memoryTypeBits = 1 << 5;  // DEVICE_LOCAL only type
+
+    auto* format_prop = lvl_find_mod_in_chain<VkAndroidHardwareBufferFormatPropertiesANDROID>(pProperties->pNext);
+    if (format_prop) {
+        // Likley using this format
+        format_prop->format = VK_FORMAT_R8G8B8A8_UNORM;
+        format_prop->externalFormat = 37;
+    }
+
+    auto* format_resolve_prop = lvl_find_mod_in_chain<VkAndroidHardwareBufferFormatResolvePropertiesANDROID>(pProperties->pNext);
+    if (format_resolve_prop) {
+        format_resolve_prop->colorAttachmentFormat = VK_FORMAT_R8G8B8A8_UNORM;
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryAndroidHardwareBufferANDROID(
+    VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_ANDROID_KHR */
+
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+static VKAPI_ATTR VkResult VKAPI_CALL CreateExecutionGraphPipelinesAMDX(VkDevice device, VkPipelineCache pipelineCache,
+                                                                        uint32_t createInfoCount,
+                                                                        const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos,
+                                                                        const VkAllocationCallbacks* pAllocator,
+                                                                        VkPipeline* pPipelines) {
+    unique_lock_t lock(global_lock);
+    for (uint32_t i = 0; i < createInfoCount; ++i) {
+        pPipelines[i] = (VkPipeline)global_unique_handle++;
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetExecutionGraphPipelineScratchSizeAMDX(VkDevice device, VkPipeline executionGraph,
+                                                                               VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetExecutionGraphPipelineNodeIndexAMDX(
+    VkDevice device, VkPipeline executionGraph, const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, uint32_t* pNodeIndex) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdInitializeGraphScratchMemoryAMDX(VkCommandBuffer commandBuffer, VkPipeline executionGraph,
+                                                                      VkDeviceAddress scratch, VkDeviceSize scratchSize) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDispatchGraphAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch,
+                                                       VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDispatchGraphIndirectAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch,
+                                                               VkDeviceSize scratchSize,
+                                                               const VkDispatchGraphCountInfoAMDX* pCountInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDispatchGraphIndirectCountAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch,
+                                                                    VkDeviceSize scratchSize, VkDeviceAddress countInfo) {
+    // Not a CREATE or DESTROY function
+}
+#endif /* VK_ENABLE_BETA_EXTENSIONS */
+static VKAPI_ATTR VkResult VKAPI_CALL WriteSamplerDescriptorsEXT(VkDevice device, uint32_t samplerCount,
+                                                                 const VkSamplerCreateInfo* pSamplers,
+                                                                 const VkHostAddressRangeEXT* pDescriptors) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL WriteResourceDescriptorsEXT(VkDevice device, uint32_t resourceCount,
+                                                                  const VkResourceDescriptorInfoEXT* pResources,
+                                                                  const VkHostAddressRangeEXT* pDescriptors) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBindSamplerHeapEXT(VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBindResourceHeapEXT(VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdPushDataEXT(VkCommandBuffer commandBuffer, const VkPushDataInfoEXT* pPushDataInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetImageOpaqueCaptureDataEXT(VkDevice device, uint32_t imageCount, const VkImage* pImages,
+                                                                   VkHostAddressRangeEXT* pDatas) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkDeviceSize VKAPI_CALL GetPhysicalDeviceDescriptorSizeEXT(VkPhysicalDevice physicalDevice,
+                                                                             VkDescriptorType descriptorType) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL RegisterCustomBorderColorEXT(VkDevice device,
+                                                                   const VkSamplerCustomBorderColorCreateInfoEXT* pBorderColor,
+                                                                   VkBool32 requestIndex, uint32_t* pIndex) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL UnregisterCustomBorderColorEXT(VkDevice device, uint32_t index) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetTensorOpaqueCaptureDataARM(VkDevice device, uint32_t tensorCount,
+                                                                    const VkTensorARM* pTensors, VkHostAddressRangeEXT* pDatas) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer,
+                                                           const VkSampleLocationsInfoEXT* pSampleLocationsInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice,
+                                                                            VkSampleCountFlagBits samples,
+                                                                            VkMultisamplePropertiesEXT* pMultisampleProperties) {
+    if (pMultisampleProperties) {
+        // arbitrary
+        pMultisampleProperties->maxSampleLocationGridSize = {32, 32};
+    }
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image,
+                                                                             VkImageDrmFormatModifierPropertiesEXT* pProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo,
+                                                               const VkAllocationCallbacks* pAllocator,
+                                                               VkValidationCacheEXT* pValidationCache) {
+    unique_lock_t lock(global_lock);
+    *pValidationCache = (VkValidationCacheEXT)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache,
+                                                            const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL MergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache,
+                                                               uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache,
+                                                                size_t* pDataSize, void* pData) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView,
+                                                            VkImageLayout imageLayout) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport,
+                                                                     uint32_t viewportCount,
+                                                                     const VkShadingRatePaletteNV* pShadingRatePalettes) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer,
+                                                            VkCoarseSampleOrderTypeNV sampleOrderType,
+                                                            uint32_t customSampleOrderCount,
+                                                            const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureNV(VkDevice device,
+                                                                    const VkAccelerationStructureCreateInfoNV* pCreateInfo,
+                                                                    const VkAllocationCallbacks* pAllocator,
+                                                                    VkAccelerationStructureNV* pAccelerationStructure) {
+    unique_lock_t lock(global_lock);
+    *pAccelerationStructure = (VkAccelerationStructureNV)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure,
+                                                                 const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureMemoryRequirementsNV(
+    VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) {
+    // arbitrary
+    pMemoryRequirements->memoryRequirements.size = 4096;
+    pMemoryRequirements->memoryRequirements.alignment = 1;
+    pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL BindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount,
+                                                                        const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer,
+                                                                  const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData,
+                                                                  VkDeviceSize instanceOffset, VkBool32 update,
+                                                                  VkAccelerationStructureNV dst, VkAccelerationStructureNV src,
+                                                                  VkBuffer scratch, VkDeviceSize scratchOffset) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst,
+                                                                 VkAccelerationStructureNV src,
+                                                                 VkCopyAccelerationStructureModeKHR mode) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer,
+                                                 VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer,
+                                                 VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride,
+                                                 VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset,
+                                                 VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer,
+                                                 VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride,
+                                                 uint32_t width, uint32_t height, uint32_t depth) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache,
+                                                                  uint32_t createInfoCount,
+                                                                  const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
+                                                                  const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
+    unique_lock_t lock(global_lock);
+    for (uint32_t i = 0; i < createInfoCount; ++i) {
+        pPipelines[i] = (VkPipeline)global_unique_handle++;
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup,
+                                                                         uint32_t groupCount, size_t dataSize, void* pData) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup,
+                                                                        uint32_t groupCount, size_t dataSize, void* pData) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureHandleNV(VkDevice device,
+                                                                       VkAccelerationStructureNV accelerationStructure,
+                                                                       size_t dataSize, void* pData) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesNV(
+    VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures,
+    VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL
+GetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer,
+                                  VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) {
+    pMemoryHostPointerProperties->memoryTypeBits = 1 << 5;  // DEVICE_LOCAL only type
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage,
+                                                          VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage,
+                                                           VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice,
+                                                                                   uint32_t* pTimeDomainCount,
+                                                                                   VkTimeDomainKHR* pTimeDomains) {
+    if (!pTimeDomains) {
+        *pTimeDomainCount = 1;
+    } else {
+        // arbitrary
+        *pTimeDomains = VK_TIME_DOMAIN_DEVICE_EXT;
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount,
+                                                                 const VkCalibratedTimestampInfoKHR* pTimestampInfos,
+                                                                 uint64_t* pTimestamps, uint64_t* pMaxDeviation) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                             uint32_t drawCount, uint32_t stride) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                                                  VkDeviceSize offset, VkBuffer countBuffer,
+                                                                  VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+                                                                  uint32_t stride) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorEnableNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor,
+                                                                 uint32_t exclusiveScissorCount,
+                                                                 const VkBool32* pExclusiveScissorEnables) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor,
+                                                           uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount,
+                                                           VkCheckpointDataNV* pCheckpointData) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount,
+                                                            VkCheckpointData2NV* pCheckpointData) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL SetSwapchainPresentTimingQueueSizeEXT(VkDevice device, VkSwapchainKHR swapchain,
+                                                                            uint32_t size) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainTimingPropertiesEXT(VkDevice device, VkSwapchainKHR swapchain,
+                                                                      VkSwapchainTimingPropertiesEXT* pSwapchainTimingProperties,
+                                                                      uint64_t* pSwapchainTimingPropertiesCounter) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainTimeDomainPropertiesEXT(
+    VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimeDomainPropertiesEXT* pSwapchainTimeDomainProperties,
+    uint64_t* pTimeDomainsCounter) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL
+GetPastPresentationTimingEXT(VkDevice device, const VkPastPresentationTimingInfoEXT* pPastPresentationTimingInfo,
+                             VkPastPresentationTimingPropertiesEXT* pPastPresentationTimingProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL InitializePerformanceApiINTEL(VkDevice device,
+                                                                    const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL UninitializePerformanceApiINTEL(VkDevice device) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer,
+                                                                   const VkPerformanceMarkerInfoINTEL* pMarkerInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer,
+                                                                         const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer,
+                                                                     const VkPerformanceOverrideInfoINTEL* pOverrideInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL
+AcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
+                                     VkPerformanceConfigurationINTEL* pConfiguration) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL ReleasePerformanceConfigurationINTEL(VkDevice device,
+                                                                           VkPerformanceConfigurationINTEL configuration) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL QueueSetPerformanceConfigurationINTEL(VkQueue queue,
+                                                                            VkPerformanceConfigurationINTEL configuration) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter,
+                                                                   VkPerformanceValueINTEL* pValue) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL SetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) {
+    // Not a CREATE or DESTROY function
+}
+#ifdef VK_USE_PLATFORM_FUCHSIA
+static VKAPI_ATTR VkResult VKAPI_CALL CreateImagePipeSurfaceFUCHSIA(VkInstance instance,
+                                                                    const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
+                                                                    const VkAllocationCallbacks* pAllocator,
+                                                                    VkSurfaceKHR* pSurface) {
+    unique_lock_t lock(global_lock);
+    *pSurface = (VkSurfaceKHR)global_unique_handle++;
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_FUCHSIA */
+
+#ifdef VK_USE_PLATFORM_METAL_EXT
+static VKAPI_ATTR VkResult VKAPI_CALL CreateMetalSurfaceEXT(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
+                                                            const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    unique_lock_t lock(global_lock);
+    *pSurface = (VkSurfaceKHR)global_unique_handle++;
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_METAL_EXT */
+static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
+    return GetBufferDeviceAddress(device, pInfo);
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
+                                                                         VkPhysicalDeviceToolProperties* pToolProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice,
+                                                                                     uint32_t* pPropertyCount,
+                                                                                     VkCooperativeMatrixPropertiesNV* pProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
+    VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDevice physicalDevice,
+                                                                               const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+                                                                               uint32_t* pPresentModeCount,
+                                                                               VkPresentModeKHR* pPresentModes) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL AcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL ReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModes2EXT(VkDevice device,
+                                                                            const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+                                                                            VkDeviceGroupPresentModeFlagsKHR* pModes) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_WIN32_KHR */
+static VKAPI_ATTR VkResult VKAPI_CALL CreateHeadlessSurfaceEXT(VkInstance instance,
+                                                               const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,
+                                                               const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    unique_lock_t lock(global_lock);
+    *pSurface = (VkSurfaceKHR)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
+                                                       uint16_t lineStipplePattern) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL ResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
+                                                    uint32_t queryCount) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount,
+                                                             const VkViewport* pViewports) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount,
+                                                            const VkRect2D* pScissors) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+                                                           uint32_t bindingCount, const VkBuffer* pBuffers,
+                                                           const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes,
+                                                           const VkDeviceSize* pStrides) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp,
+                                                     VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToImageEXT(VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToMemoryEXT(VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToImageEXT(VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL TransitionImageLayoutEXT(VkDevice device, uint32_t transitionCount,
+                                                               const VkHostImageLayoutTransitionInfo* pTransitions) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2EXT(VkDevice device, VkImage image,
+                                                                const VkImageSubresource2* pSubresource,
+                                                                VkSubresourceLayout2* pLayout) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL ReleaseSwapchainImagesEXT(VkDevice device,
+                                                                const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsNV(VkDevice device,
+                                                                           const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo,
+                                                                           VkMemoryRequirements2* pMemoryRequirements) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer,
+                                                                   const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed,
+                                                                const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
+                                                               VkPipeline pipeline, uint32_t groupIndex) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNV(VkDevice device,
+                                                                     const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,
+                                                                     const VkAllocationCallbacks* pAllocator,
+                                                                     VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) {
+    unique_lock_t lock(global_lock);
+    *pIndirectCommandsLayout = (VkIndirectCommandsLayoutNV)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNV(VkDevice device,
+                                                                  VkIndirectCommandsLayoutNV indirectCommandsLayout,
+                                                                  const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias2EXT(VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT* pDepthBiasInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL AcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId,
+                                                       VkDisplayKHR* display) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo,
+                                                               const VkAllocationCallbacks* pAllocator,
+                                                               VkPrivateDataSlot* pPrivateDataSlot) {
+    unique_lock_t lock(global_lock);
+    *pPrivateDataSlot = (VkPrivateDataSlot)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot,
+                                                            const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
+                                                        VkPrivateDataSlot privateDataSlot, uint64_t data) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL GetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
+                                                    VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
+    // Not a CREATE or DESTROY function
+}
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+static VKAPI_ATTR VkResult VKAPI_CALL CreateCudaModuleNV(VkDevice device, const VkCudaModuleCreateInfoNV* pCreateInfo,
+                                                         const VkAllocationCallbacks* pAllocator, VkCudaModuleNV* pModule) {
+    unique_lock_t lock(global_lock);
+    *pModule = (VkCudaModuleNV)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetCudaModuleCacheNV(VkDevice device, VkCudaModuleNV module, size_t* pCacheSize,
+                                                           void* pCacheData) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateCudaFunctionNV(VkDevice device, const VkCudaFunctionCreateInfoNV* pCreateInfo,
+                                                           const VkAllocationCallbacks* pAllocator, VkCudaFunctionNV* pFunction) {
+    unique_lock_t lock(global_lock);
+    *pFunction = (VkCudaFunctionNV)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyCudaModuleNV(VkDevice device, VkCudaModuleNV module,
+                                                      const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyCudaFunctionNV(VkDevice device, VkCudaFunctionNV function,
+                                                        const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCudaLaunchKernelNV(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo) {
+    // Not a CREATE or DESTROY function
+}
+#endif /* VK_ENABLE_BETA_EXTENSIONS */
+static VKAPI_ATTR void VKAPI_CALL CmdDispatchTileQCOM(VkCommandBuffer commandBuffer,
+                                                      const VkDispatchTileInfoQCOM* pDispatchTileInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBeginPerTileExecutionQCOM(VkCommandBuffer commandBuffer,
+                                                               const VkPerTileBeginInfoQCOM* pPerTileBeginInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdEndPerTileExecutionQCOM(VkCommandBuffer commandBuffer,
+                                                             const VkPerTileEndInfoQCOM* pPerTileEndInfo) {
+    // Not a CREATE or DESTROY function
+}
+#ifdef VK_USE_PLATFORM_METAL_EXT
+static VKAPI_ATTR void VKAPI_CALL ExportMetalObjectsEXT(VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo) {
+    // Not a CREATE or DESTROY function
+}
+#endif /* VK_USE_PLATFORM_METAL_EXT */
+static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout,
+                                                                VkDeviceSize* pLayoutSizeInBytes) {
+    // Need to give something non-zero
+    *pLayoutSizeInBytes = 4;
+}
+static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout,
+                                                                         uint32_t binding, VkDeviceSize* pOffset) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL GetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize,
+                                                   void* pDescriptor) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount,
+                                                              const VkDescriptorBufferBindingInfoEXT* pBindingInfos) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer,
+                                                                   VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
+                                                                   uint32_t firstSet, uint32_t setCount,
+                                                                   const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer,
+                                                                             VkPipelineBindPoint pipelineBindPoint,
+                                                                             VkPipelineLayout layout, uint32_t set) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device,
+                                                                              const VkBufferCaptureDescriptorDataInfoEXT* pInfo,
+                                                                              void* pData) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetImageOpaqueCaptureDescriptorDataEXT(VkDevice device,
+                                                                             const VkImageCaptureDescriptorDataInfoEXT* pInfo,
+                                                                             void* pData) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL
+GetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetSamplerOpaqueCaptureDescriptorDataEXT(VkDevice device,
+                                                                               const VkSamplerCaptureDescriptorDataInfoEXT* pInfo,
+                                                                               void* pData) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureOpaqueCaptureDescriptorDataEXT(
+    VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer,
+                                                                  VkFragmentShadingRateNV shadingRate,
+                                                                  const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceFaultInfoEXT(VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts,
+                                                            VkDeviceFaultInfoEXT* pFaultInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+static VKAPI_ATTR VkResult VKAPI_CALL AcquireWinrtDisplayNV(VkPhysicalDevice physicalDevice, VkDisplayKHR display) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetWinrtDisplayNV(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId,
+                                                        VkDisplayKHR* pDisplay) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_WIN32_KHR */
+
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDirectFBSurfaceEXT(VkInstance instance,
+                                                               const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo,
+                                                               const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    unique_lock_t lock(global_lock);
+    *pSurface = (VkSurfaceKHR)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceDirectFBPresentationSupportEXT(VkPhysicalDevice physicalDevice,
+                                                                                      uint32_t queueFamilyIndex, IDirectFB* dfb) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_DIRECTFB_EXT */
+static VKAPI_ATTR void VKAPI_CALL CmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount,
+                                                       const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions,
+                                                       uint32_t vertexAttributeDescriptionCount,
+                                                       const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) {
+    // Not a CREATE or DESTROY function
+}
+#ifdef VK_USE_PLATFORM_FUCHSIA
+static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandleFUCHSIA(VkDevice device,
+                                                                   const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+                                                                   zx_handle_t* pZirconHandle) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL
+GetMemoryZirconHandlePropertiesFUCHSIA(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle,
+                                       VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreZirconHandleFUCHSIA(
+    VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreZirconHandleFUCHSIA(
+    VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferCollectionFUCHSIA(VkDevice device,
+                                                                    const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo,
+                                                                    const VkAllocationCallbacks* pAllocator,
+                                                                    VkBufferCollectionFUCHSIA* pCollection) {
+    unique_lock_t lock(global_lock);
+    *pCollection = (VkBufferCollectionFUCHSIA)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionImageConstraintsFUCHSIA(
+    VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionBufferConstraintsFUCHSIA(
+    VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyBufferCollectionFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection,
+                                                                 const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetBufferCollectionPropertiesFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection,
+                                                                           VkBufferCollectionPropertiesFUCHSIA* pProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_FUCHSIA */
+static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass,
+                                                                                    VkExtent2D* pMaxWorkgroupSize) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView,
+                                                              VkImageLayout imageLayout) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryRemoteAddressNV(VkDevice device,
+                                                               const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo,
+                                                               VkRemoteAddressNV* pAddress) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfoEXT* pPipelineInfo,
+                                                               VkBaseOutStructure* pPipelineProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer,
+                                                                   VkBool32 rasterizerDiscardEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) {
+    // Not a CREATE or DESTROY function
+}
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+static VKAPI_ATTR VkResult VKAPI_CALL CreateScreenSurfaceQNX(VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo,
+                                                             const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    unique_lock_t lock(global_lock);
+    *pSurface = (VkSurfaceKHR)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice,
+                                                                                    uint32_t queueFamilyIndex,
+                                                                                    struct _screen_window* window) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_SCREEN_QNX */
+static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
+                                                            const VkBool32* pColorWriteEnables) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount,
+                                                  const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount,
+                                                  uint32_t firstInstance, uint32_t stride) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount,
+                                                         const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount,
+                                                         uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo,
+                                                        const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap) {
+    unique_lock_t lock(global_lock);
+    *pMicromap = (VkMicromapEXT)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap,
+                                                     const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32_t infoCount,
+                                                       const VkMicromapBuildInfoEXT* pInfos) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL BuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR deferredOperation,
+                                                        uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation,
+                                                      const VkCopyMicromapInfoEXT* pInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation,
+                                                              const VkCopyMicromapToMemoryInfoEXT* pInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation,
+                                                              const VkCopyMemoryToMicromapInfoEXT* pInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL WriteMicromapsPropertiesEXT(VkDevice device, uint32_t micromapCount,
+                                                                  const VkMicromapEXT* pMicromaps, VkQueryType queryType,
+                                                                  size_t dataSize, void* pData, size_t stride) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer,
+                                                             const VkCopyMicromapToMemoryInfoEXT* pInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer,
+                                                             const VkCopyMemoryToMicromapInfoEXT* pInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, uint32_t micromapCount,
+                                                                 const VkMicromapEXT* pMicromaps, VkQueryType queryType,
+                                                                 VkQueryPool queryPool, uint32_t firstQuery) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL GetDeviceMicromapCompatibilityEXT(VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo,
+                                                                    VkAccelerationStructureCompatibilityKHR* pCompatibility) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL GetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType,
+                                                           const VkMicromapBuildInfoEXT* pBuildInfo,
+                                                           VkMicromapBuildSizesInfoEXT* pSizeInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawClusterHUAWEI(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY,
+                                                       uint32_t groupCountZ) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawClusterIndirectHUAWEI(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                                               VkDeviceSize offset) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL SetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL
+GetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference,
+                                           VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void** ppData) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress,
+                                                          uint32_t copyCount, uint32_t stride) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress,
+                                                                 uint32_t copyCount, uint32_t stride, VkImage dstImage,
+                                                                 VkImageLayout dstImageLayout,
+                                                                 const VkImageSubresourceLayers* pImageSubresources) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryNV(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount,
+                                                        const VkDecompressMemoryRegionNV* pDecompressMemoryRegions) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryIndirectCountNV(VkCommandBuffer commandBuffer,
+                                                                     VkDeviceAddress indirectCommandsAddress,
+                                                                     VkDeviceAddress indirectCommandsCountAddress,
+                                                                     uint32_t stride) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL GetPipelineIndirectMemoryRequirementsNV(VkDevice device,
+                                                                          const VkComputePipelineCreateInfo* pCreateInfo,
+                                                                          VkMemoryRequirements2* pMemoryRequirements) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdUpdatePipelineIndirectBufferNV(VkCommandBuffer commandBuffer,
+                                                                    VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkDeviceAddress VKAPI_CALL
+GetPipelineIndirectDeviceAddressNV(VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV* pInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+#ifdef VK_USE_PLATFORM_OHOS
+static VKAPI_ATTR VkResult VKAPI_CALL GetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer,
+                                                                    VkNativeBufferPropertiesOHOS* pProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo,
+                                                                struct OH_NativeBuffer** pBuffer) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_OHOS */
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer,
+                                                                VkSampleCountFlagBits rasterizationSamples) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples,
+                                                      const VkSampleMask* pSampleMask) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment,
+                                                            uint32_t attachmentCount, const VkBool32* pColorBlendEnables) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment,
+                                                              uint32_t attachmentCount,
+                                                              const VkColorBlendEquationEXT* pColorBlendEquations) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment,
+                                                          uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer,
+                                                                    VkTessellationDomainOrigin domainOrigin) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetConservativeRasterizationModeEXT(
+    VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer,
+                                                                            float extraPrimitiveOverestimationSize) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment,
+                                                              uint32_t attachmentCount,
+                                                              const VkColorBlendAdvancedEXT* pColorBlendAdvanced) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer,
+                                                               VkProvokingVertexModeEXT provokingVertexMode) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer,
+                                                                 VkLineRasterizationModeEXT lineRasterizationMode) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport,
+                                                          uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer,
+                                                                 VkCoverageModulationModeNV coverageModulationMode) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer,
+                                                                        VkBool32 coverageModulationTableEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer,
+                                                                  uint32_t coverageModulationTableCount,
+                                                                  const float* pCoverageModulationTable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer,
+                                                                           VkBool32 representativeFragmentTestEnable) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer,
+                                                                VkCoverageReductionModeNV coverageReductionMode) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateTensorARM(VkDevice device, const VkTensorCreateInfoARM* pCreateInfo,
+                                                      const VkAllocationCallbacks* pAllocator, VkTensorARM* pTensor) {
+    unique_lock_t lock(global_lock);
+    *pTensor = (VkTensorARM)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyTensorARM(VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateTensorViewARM(VkDevice device, const VkTensorViewCreateInfoARM* pCreateInfo,
+                                                          const VkAllocationCallbacks* pAllocator, VkTensorViewARM* pView) {
+    unique_lock_t lock(global_lock);
+    *pView = (VkTensorViewARM)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyTensorViewARM(VkDevice device, VkTensorViewARM tensorView,
+                                                       const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR void VKAPI_CALL GetTensorMemoryRequirementsARM(VkDevice device, const VkTensorMemoryRequirementsInfoARM* pInfo,
+                                                                 VkMemoryRequirements2* pMemoryRequirements) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL BindTensorMemoryARM(VkDevice device, uint32_t bindInfoCount,
+                                                          const VkBindTensorMemoryInfoARM* pBindInfos) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL GetDeviceTensorMemoryRequirementsARM(VkDevice device,
+                                                                       const VkDeviceTensorMemoryRequirementsARM* pInfo,
+                                                                       VkMemoryRequirements2* pMemoryRequirements) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyTensorARM(VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM* pCopyTensorInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalTensorPropertiesARM(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalTensorInfoARM* pExternalTensorInfo,
+    VkExternalTensorPropertiesARM* pExternalTensorProperties) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetTensorOpaqueCaptureDescriptorDataARM(VkDevice device,
+                                                                              const VkTensorCaptureDescriptorDataInfoARM* pInfo,
+                                                                              void* pData) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL
+GetTensorViewOpaqueCaptureDescriptorDataARM(VkDevice device, const VkTensorViewCaptureDescriptorDataInfoARM* pInfo, void* pData) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL GetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule,
+                                                               VkShaderModuleIdentifierEXT* pIdentifier) {
+    if (pIdentifier) {
+        // arbitrary
+        pIdentifier->identifierSize = 1;
+        pIdentifier->identifier[0] = 0x01;
+    }
+}
+static VKAPI_ATTR void VKAPI_CALL GetShaderModuleCreateInfoIdentifierEXT(VkDevice device,
+                                                                         const VkShaderModuleCreateInfo* pCreateInfo,
+                                                                         VkShaderModuleIdentifierEXT* pIdentifier) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceOpticalFlowImageFormatsNV(
+    VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount,
+    VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateOpticalFlowSessionNV(VkDevice device,
+                                                                 const VkOpticalFlowSessionCreateInfoNV* pCreateInfo,
+                                                                 const VkAllocationCallbacks* pAllocator,
+                                                                 VkOpticalFlowSessionNV* pSession) {
+    unique_lock_t lock(global_lock);
+    *pSession = (VkOpticalFlowSessionNV)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionNV session,
+                                                              const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL BindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSessionNV session,
+                                                                    VkOpticalFlowSessionBindingPointNV bindingPoint,
+                                                                    VkImageView view, VkImageLayout layout) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session,
+                                                          const VkOpticalFlowExecuteInfoNV* pExecuteInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL AntiLagUpdateAMD(VkDevice device, const VkAntiLagDataAMD* pData) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateShadersEXT(VkDevice device, uint32_t createInfoCount,
+                                                       const VkShaderCreateInfoEXT* pCreateInfos,
+                                                       const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders) {
+    unique_lock_t lock(global_lock);
+    for (uint32_t i = 0; i < createInfoCount; ++i) {
+        pShaders[i] = (VkShaderEXT)global_unique_handle++;
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyShaderEXT(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetShaderBinaryDataEXT(VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBindShadersEXT(VkCommandBuffer commandBuffer, uint32_t stageCount,
+                                                    const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampRangeEXT(VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode,
+                                                           const VkDepthClampRangeEXT* pDepthClampRange) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer,
+                                                                       uint32_t* pPropertiesCount,
+                                                                       VkTilePropertiesQCOM* pProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo,
+                                                                            VkTilePropertiesQCOM* pProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeVectorPropertiesNV(VkPhysicalDevice physicalDevice,
+                                                                                     uint32_t* pPropertyCount,
+                                                                                     VkCooperativeVectorPropertiesNV* pProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL ConvertCooperativeVectorMatrixNV(VkDevice device,
+                                                                       const VkConvertCooperativeVectorMatrixInfoNV* pInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdConvertCooperativeVectorMatrixNV(VkCommandBuffer commandBuffer, uint32_t infoCount,
+                                                                      const VkConvertCooperativeVectorMatrixInfoNV* pInfos) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL SetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain,
+                                                            const VkLatencySleepModeInfoNV* pSleepModeInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL LatencySleepNV(VkDevice device, VkSwapchainKHR swapchain,
+                                                     const VkLatencySleepInfoNV* pSleepInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL SetLatencyMarkerNV(VkDevice device, VkSwapchainKHR swapchain,
+                                                     const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL GetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain,
+                                                      VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL QueueNotifyOutOfBandNV(VkQueue queue, const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDataGraphPipelinesARM(VkDevice device, VkDeferredOperationKHR deferredOperation,
+                                                                  VkPipelineCache pipelineCache, uint32_t createInfoCount,
+                                                                  const VkDataGraphPipelineCreateInfoARM* pCreateInfos,
+                                                                  const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
+    unique_lock_t lock(global_lock);
+    for (uint32_t i = 0; i < createInfoCount; ++i) {
+        pPipelines[i] = (VkPipeline)global_unique_handle++;
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateDataGraphPipelineSessionARM(VkDevice device,
+                                                                        const VkDataGraphPipelineSessionCreateInfoARM* pCreateInfo,
+                                                                        const VkAllocationCallbacks* pAllocator,
+                                                                        VkDataGraphPipelineSessionARM* pSession) {
+    unique_lock_t lock(global_lock);
+    *pSession = (VkDataGraphPipelineSessionARM)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetDataGraphPipelineSessionBindPointRequirementsARM(
+    VkDevice device, const VkDataGraphPipelineSessionBindPointRequirementsInfoARM* pInfo, uint32_t* pBindPointRequirementCount,
+    VkDataGraphPipelineSessionBindPointRequirementARM* pBindPointRequirements) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL GetDataGraphPipelineSessionMemoryRequirementsARM(
+    VkDevice device, const VkDataGraphPipelineSessionMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL BindDataGraphPipelineSessionMemoryARM(
+    VkDevice device, uint32_t bindInfoCount, const VkBindDataGraphPipelineSessionMemoryInfoARM* pBindInfos) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyDataGraphPipelineSessionARM(VkDevice device, VkDataGraphPipelineSessionARM session,
+                                                                     const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDispatchDataGraphARM(VkCommandBuffer commandBuffer, VkDataGraphPipelineSessionARM session,
+                                                          const VkDataGraphPipelineDispatchInfoARM* pInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetDataGraphPipelineAvailablePropertiesARM(VkDevice device,
+                                                                                 const VkDataGraphPipelineInfoARM* pPipelineInfo,
+                                                                                 uint32_t* pPropertiesCount,
+                                                                                 VkDataGraphPipelinePropertyARM* pProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetDataGraphPipelinePropertiesARM(VkDevice device,
+                                                                        const VkDataGraphPipelineInfoARM* pPipelineInfo,
+                                                                        uint32_t propertiesCount,
+                                                                        VkDataGraphPipelinePropertyQueryResultARM* pProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(
+    VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pQueueFamilyDataGraphPropertyCount,
+    VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM* pQueueFamilyDataGraphProcessingEngineInfo,
+    VkQueueFamilyDataGraphProcessingEnginePropertiesARM* pQueueFamilyDataGraphProcessingEngineProperties) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer,
+                                                                        VkImageAspectFlags aspectMask) {
+    // Not a CREATE or DESTROY function
+}
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+static VKAPI_ATTR VkResult VKAPI_CALL GetScreenBufferPropertiesQNX(VkDevice device, const struct _screen_buffer* buffer,
+                                                                   VkScreenBufferPropertiesQNX* pProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_SCREEN_QNX */
+static VKAPI_ATTR void VKAPI_CALL CmdBindTileMemoryQCOM(VkCommandBuffer commandBuffer,
+                                                        const VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryEXT(VkCommandBuffer commandBuffer,
+                                                         const VkDecompressMemoryInfoEXT* pDecompressMemoryInfoEXT) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryIndirectCountEXT(VkCommandBuffer commandBuffer,
+                                                                      VkMemoryDecompressionMethodFlagsEXT decompressionMethod,
+                                                                      VkDeviceAddress indirectCommandsAddress,
+                                                                      VkDeviceAddress indirectCommandsCountAddress,
+                                                                      uint32_t maxDecompressionCount, uint32_t stride) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateExternalComputeQueueNV(VkDevice device,
+                                                                   const VkExternalComputeQueueCreateInfoNV* pCreateInfo,
+                                                                   const VkAllocationCallbacks* pAllocator,
+                                                                   VkExternalComputeQueueNV* pExternalQueue) {
+    unique_lock_t lock(global_lock);
+    *pExternalQueue = (VkExternalComputeQueueNV)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyExternalComputeQueueNV(VkDevice device, VkExternalComputeQueueNV externalQueue,
+                                                                const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR void VKAPI_CALL GetExternalComputeQueueDataNV(VkExternalComputeQueueNV externalQueue,
+                                                                VkExternalComputeQueueDataParamsNV* params, void* pData) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL GetClusterAccelerationStructureBuildSizesNV(
+    VkDevice device, const VkClusterAccelerationStructureInputInfoNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBuildClusterAccelerationStructureIndirectNV(
+    VkCommandBuffer commandBuffer, const VkClusterAccelerationStructureCommandsInfoNV* pCommandInfos) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL
+GetPartitionedAccelerationStructuresBuildSizesNV(VkDevice device, const VkPartitionedAccelerationStructureInstancesInputNV* pInfo,
+                                                 VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBuildPartitionedAccelerationStructuresNV(
+    VkCommandBuffer commandBuffer, const VkBuildPartitionedAccelerationStructureInfoNV* pBuildInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsEXT(
+    VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, VkMemoryRequirements2* pMemoryRequirements) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsEXT(VkCommandBuffer commandBuffer,
+                                                                    const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo,
+                                                                    VkCommandBuffer stateCommandBuffer) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsEXT(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed,
+                                                                 const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutEXT(VkDevice device,
+                                                                      const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo,
+                                                                      const VkAllocationCallbacks* pAllocator,
+                                                                      VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout) {
+    unique_lock_t lock(global_lock);
+    *pIndirectCommandsLayout = (VkIndirectCommandsLayoutEXT)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutEXT(VkDevice device,
+                                                                   VkIndirectCommandsLayoutEXT indirectCommandsLayout,
+                                                                   const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectExecutionSetEXT(VkDevice device,
+                                                                    const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo,
+                                                                    const VkAllocationCallbacks* pAllocator,
+                                                                    VkIndirectExecutionSetEXT* pIndirectExecutionSet) {
+    unique_lock_t lock(global_lock);
+    *pIndirectExecutionSet = (VkIndirectExecutionSetEXT)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyIndirectExecutionSetEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet,
+                                                                 const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR void VKAPI_CALL UpdateIndirectExecutionSetPipelineEXT(
+    VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount,
+    const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL UpdateIndirectExecutionSetShaderEXT(
+    VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount,
+    const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites) {
+    // Not a CREATE or DESTROY function
+}
+#ifdef VK_USE_PLATFORM_OHOS
+static VKAPI_ATTR VkResult VKAPI_CALL CreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo,
+                                                        const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    unique_lock_t lock(global_lock);
+    *pSurface = (VkSurfaceKHR)global_unique_handle++;
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_OHOS */
+static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(
+    VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+#ifdef VK_USE_PLATFORM_METAL_EXT
+static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryMetalHandleEXT(VkDevice device,
+                                                              const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo,
+                                                              void** pHandle) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL
+GetMemoryMetalHandlePropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHandle,
+                                  VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_METAL_EXT */
+static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(
+    VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterARM* pCounters,
+    VkPerformanceCounterDescriptionARM* pCounterDescriptions) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceShaderInstrumentationMetricsARM(
+    VkPhysicalDevice physicalDevice, uint32_t* pDescriptionCount, VkShaderInstrumentationMetricDescriptionARM* pDescriptions) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateShaderInstrumentationARM(VkDevice device,
+                                                                     const VkShaderInstrumentationCreateInfoARM* pCreateInfo,
+                                                                     const VkAllocationCallbacks* pAllocator,
+                                                                     VkShaderInstrumentationARM* pInstrumentation) {
+    unique_lock_t lock(global_lock);
+    *pInstrumentation = (VkShaderInstrumentationARM)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyShaderInstrumentationARM(VkDevice device, VkShaderInstrumentationARM instrumentation,
+                                                                  const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBeginShaderInstrumentationARM(VkCommandBuffer commandBuffer,
+                                                                   VkShaderInstrumentationARM instrumentation) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdEndShaderInstrumentationARM(VkCommandBuffer commandBuffer) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetShaderInstrumentationValuesARM(VkDevice device, VkShaderInstrumentationARM instrumentation,
+                                                                        uint32_t* pMetricBlockCount, void* pMetricValues,
+                                                                        VkShaderInstrumentationValuesFlagsARM flags) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL ClearShaderInstrumentationMetricsARM(VkDevice device,
+                                                                       VkShaderInstrumentationARM instrumentation) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdEndRendering2EXT(VkCommandBuffer commandBuffer,
+                                                      const VkRenderingEndInfoKHR* pRenderingEndInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBeginCustomResolveEXT(VkCommandBuffer commandBuffer,
+                                                           const VkBeginCustomResolveInfoEXT* pBeginCustomResolveInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetComputeOccupancyPriorityNV(VkCommandBuffer commandBuffer,
+                                                                   const VkComputeOccupancyPriorityParametersNV* pParameters) {
+    // Not a CREATE or DESTROY function
+}
+#ifdef VK_USE_PLATFORM_UBM_SEC
+static VKAPI_ATTR VkResult VKAPI_CALL CreateUbmSurfaceSEC(VkInstance instance, const VkUbmSurfaceCreateInfoSEC* pCreateInfo,
+                                                          const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    unique_lock_t lock(global_lock);
+    *pSurface = (VkSurfaceKHR)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceUbmPresentationSupportSEC(VkPhysicalDevice physicalDevice,
+                                                                                 uint32_t queueFamilyIndex,
+                                                                                 struct ubm_device* device) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_UBM_SEC */
+static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR(VkDevice device,
+                                                                     const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
+                                                                     const VkAllocationCallbacks* pAllocator,
+                                                                     VkAccelerationStructureKHR* pAccelerationStructure) {
+    unique_lock_t lock(global_lock);
+    *pAccelerationStructure = (VkAccelerationStructureKHR)global_unique_handle++;
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure,
+                                                                  const VkAllocationCallbacks* pAllocator) {
+    // Destroy object
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresKHR(
+    VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
+    const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresIndirectKHR(
+    VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
+    const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides,
+    const uint32_t* const* ppMaxPrimitiveCounts) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL
+BuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount,
+                               const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
+                               const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation,
+                                                                   const VkCopyAccelerationStructureInfoKHR* pInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureToMemoryKHR(
+    VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToAccelerationStructureKHR(
+    VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL WriteAccelerationStructuresPropertiesKHR(
+    VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures,
+    VkQueryType queryType, size_t dataSize, void* pData, size_t stride) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer,
+                                                                  const VkCopyAccelerationStructureInfoKHR* pInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer,
+                                                                          const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer,
+                                                                          const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkDeviceAddress VKAPI_CALL
+GetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) {
+    // arbitrary - need to be aligned to 256 bytes
+    return 0x262144;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesKHR(
+    VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures,
+    VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL
+GetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo,
+                                               VkAccelerationStructureCompatibilityKHR* pCompatibility) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureBuildSizesKHR(
+    VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo,
+    const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) {
+    // arbitrary
+    pSizeInfo->accelerationStructureSize = 4;
+    pSizeInfo->updateScratchSize = 4;
+    pSizeInfo->buildScratchSize = 4;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysKHR(VkCommandBuffer commandBuffer,
+                                                  const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
+                                                  const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
+                                                  const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
+                                                  const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
+                                                  uint32_t width, uint32_t height, uint32_t depth) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation,
+                                                                   VkPipelineCache pipelineCache, uint32_t createInfoCount,
+                                                                   const VkRayTracingPipelineCreateInfoKHR* pCreateInfos,
+                                                                   const VkAllocationCallbacks* pAllocator,
+                                                                   VkPipeline* pPipelines) {
+    unique_lock_t lock(global_lock);
+    for (uint32_t i = 0; i < createInfoCount; ++i) {
+        pPipelines[i] = (VkPipeline)global_unique_handle++;
+    }
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline,
+                                                                                      uint32_t firstGroup, uint32_t groupCount,
+                                                                                      size_t dataSize, void* pData) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer,
+                                                          const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
+                                                          const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
+                                                          const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
+                                                          const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
+                                                          VkDeviceAddress indirectDeviceAddress) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR VkDeviceSize VKAPI_CALL GetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group,
+                                                                               VkShaderGroupShaderKHR groupShader) {
+    // Not a CREATE or DESTROY function
+    return VK_SUCCESS;
+}
+static VKAPI_ATTR void VKAPI_CALL CmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksEXT(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY,
+                                                      uint32_t groupCountZ) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                              uint32_t drawCount, uint32_t stride) {
+    // Not a CREATE or DESTROY function
+}
+static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountEXT(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                                                   VkDeviceSize offset, VkBuffer countBuffer,
+                                                                   VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+                                                                   uint32_t stride) {
+    // Not a CREATE or DESTROY function
+}
+
+}  // namespace vkmock
diff --git a/tools/Vulkan-Tools/icd/generated/vk_typemap_helper.h b/tools/Vulkan-Tools/icd/generated/vk_typemap_helper.h
new file mode 100644
index 00000000..bec17b6d
--- /dev/null
+++ b/tools/Vulkan-Tools/icd/generated/vk_typemap_helper.h
@@ -0,0 +1,13650 @@
+// *** THIS FILE IS GENERATED - DO NOT EDIT ***
+// See vulkan_tools_helper_file_generator.py for modifications
+
+/***************************************************************************
+ *
+ * Copyright (c) 2015-2017 The Khronos Group Inc.
+ * Copyright (c) 2015-2017 Valve Corporation
+ * Copyright (c) 2015-2017 LunarG, Inc.
+ * Copyright (c) 2015-2017 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Mark Lobodzinski <mark@lunarg.com>
+ * Author: Courtney Goeltzenleuchter <courtneygo@google.com>
+ * Author: Tobin Ehlis <tobine@google.com>
+ * Author: Chris Forbes <chrisforbes@google.com>
+ * Author: John Zulauf<jzulauf@lunarg.com>
+ *
+ ****************************************************************************/
+
+#pragma once
+#include <vulkan/vulkan.h>
+
+// These empty generic templates are specialized for each type with sType
+// members and for each sType -- providing a two way map between structure
+// types and sTypes
+
+template <VkStructureType id>
+struct LvlSTypeMap {};
+template <typename T>
+struct LvlTypeMap {};
+
+// Map type VkApplicationInfo to id VK_STRUCTURE_TYPE_APPLICATION_INFO
+template <>
+struct LvlTypeMap<VkApplicationInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_APPLICATION_INFO> {
+    typedef VkApplicationInfo Type;
+};
+
+// Map type VkInstanceCreateInfo to id VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkInstanceCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO> {
+    typedef VkInstanceCreateInfo Type;
+};
+
+// Map type VkDeviceQueueCreateInfo to id VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkDeviceQueueCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO> {
+    typedef VkDeviceQueueCreateInfo Type;
+};
+
+// Map type VkDeviceCreateInfo to id VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkDeviceCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO> {
+    typedef VkDeviceCreateInfo Type;
+};
+
+// Map type VkSubmitInfo to id VK_STRUCTURE_TYPE_SUBMIT_INFO
+template <>
+struct LvlTypeMap<VkSubmitInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBMIT_INFO> {
+    typedef VkSubmitInfo Type;
+};
+
+// Map type VkMappedMemoryRange to id VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE
+template <>
+struct LvlTypeMap<VkMappedMemoryRange> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE> {
+    typedef VkMappedMemoryRange Type;
+};
+
+// Map type VkMemoryAllocateInfo to id VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO
+template <>
+struct LvlTypeMap<VkMemoryAllocateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO> {
+    typedef VkMemoryAllocateInfo Type;
+};
+
+// Map type VkBindSparseInfo to id VK_STRUCTURE_TYPE_BIND_SPARSE_INFO
+template <>
+struct LvlTypeMap<VkBindSparseInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_SPARSE_INFO> {
+    typedef VkBindSparseInfo Type;
+};
+
+// Map type VkFenceCreateInfo to id VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkFenceCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_FENCE_CREATE_INFO> {
+    typedef VkFenceCreateInfo Type;
+};
+
+// Map type VkSemaphoreCreateInfo to id VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkSemaphoreCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO> {
+    typedef VkSemaphoreCreateInfo Type;
+};
+
+// Map type VkQueryPoolCreateInfo to id VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO
+template <>
+struct LvlTypeMap<VkQueryPoolCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO> {
+    typedef VkQueryPoolCreateInfo Type;
+};
+
+// Map type VkBufferCreateInfo to id VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO
+template <>
+struct LvlTypeMap<VkBufferCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO> {
+    typedef VkBufferCreateInfo Type;
+};
+
+// Map type VkImageCreateInfo to id VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkImageCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO> {
+    typedef VkImageCreateInfo Type;
+};
+
+// Map type VkImageViewCreateInfo to id VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
+template <>
+struct LvlTypeMap<VkImageViewCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO> {
+    typedef VkImageViewCreateInfo Type;
+};
+
+// Map type VkCommandPoolCreateInfo to id VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO
+template <>
+struct LvlTypeMap<VkCommandPoolCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO> {
+    typedef VkCommandPoolCreateInfo Type;
+};
+
+// Map type VkCommandBufferAllocateInfo to id VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO
+template <>
+struct LvlTypeMap<VkCommandBufferAllocateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO> {
+    typedef VkCommandBufferAllocateInfo Type;
+};
+
+// Map type VkCommandBufferInheritanceInfo to id VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO
+template <>
+struct LvlTypeMap<VkCommandBufferInheritanceInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO> {
+    typedef VkCommandBufferInheritanceInfo Type;
+};
+
+// Map type VkCommandBufferBeginInfo to id VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
+template <>
+struct LvlTypeMap<VkCommandBufferBeginInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO> {
+    typedef VkCommandBufferBeginInfo Type;
+};
+
+// Map type VkBufferMemoryBarrier to id VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER
+template <>
+struct LvlTypeMap<VkBufferMemoryBarrier> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER> {
+    typedef VkBufferMemoryBarrier Type;
+};
+
+// Map type VkImageMemoryBarrier to id VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
+template <>
+struct LvlTypeMap<VkImageMemoryBarrier> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER> {
+    typedef VkImageMemoryBarrier Type;
+};
+
+// Map type VkMemoryBarrier to id VK_STRUCTURE_TYPE_MEMORY_BARRIER
+template <>
+struct LvlTypeMap<VkMemoryBarrier> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_BARRIER> {
+    typedef VkMemoryBarrier Type;
+};
+
+// Map type VkEventCreateInfo to id VK_STRUCTURE_TYPE_EVENT_CREATE_INFO
+template <>
+struct LvlTypeMap<VkEventCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EVENT_CREATE_INFO> {
+    typedef VkEventCreateInfo Type;
+};
+
+// Map type VkBufferViewCreateInfo to id VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO
+template <>
+struct LvlTypeMap<VkBufferViewCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO> {
+    typedef VkBufferViewCreateInfo Type;
+};
+
+// Map type VkShaderModuleCreateInfo to id VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkShaderModuleCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO> {
+    typedef VkShaderModuleCreateInfo Type;
+};
+
+// Map type VkPipelineCacheCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkPipelineCacheCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO> {
+    typedef VkPipelineCacheCreateInfo Type;
+};
+
+// Map type VkPipelineShaderStageCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkPipelineShaderStageCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO> {
+    typedef VkPipelineShaderStageCreateInfo Type;
+};
+
+// Map type VkComputePipelineCreateInfo to id VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkComputePipelineCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO> {
+    typedef VkComputePipelineCreateInfo Type;
+};
+
+// Map type VkPipelineLayoutCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO
+template <>
+struct LvlTypeMap<VkPipelineLayoutCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO> {
+    typedef VkPipelineLayoutCreateInfo Type;
+};
+
+// Map type VkSamplerCreateInfo to id VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
+template <>
+struct LvlTypeMap<VkSamplerCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO> {
+    typedef VkSamplerCreateInfo Type;
+};
+
+// Map type VkCopyDescriptorSet to id VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET
+template <>
+struct LvlTypeMap<VkCopyDescriptorSet> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET> {
+    typedef VkCopyDescriptorSet Type;
+};
+
+// Map type VkDescriptorPoolCreateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO
+template <>
+struct LvlTypeMap<VkDescriptorPoolCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO> {
+    typedef VkDescriptorPoolCreateInfo Type;
+};
+
+// Map type VkDescriptorSetAllocateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO
+template <>
+struct LvlTypeMap<VkDescriptorSetAllocateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO> {
+    typedef VkDescriptorSetAllocateInfo Type;
+};
+
+// Map type VkDescriptorSetLayoutCreateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
+template <>
+struct LvlTypeMap<VkDescriptorSetLayoutCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO> {
+    typedef VkDescriptorSetLayoutCreateInfo Type;
+};
+
+// Map type VkWriteDescriptorSet to id VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET
+template <>
+struct LvlTypeMap<VkWriteDescriptorSet> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET> {
+    typedef VkWriteDescriptorSet Type;
+};
+
+// Map type VkPipelineColorBlendStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkPipelineColorBlendStateCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO> {
+    typedef VkPipelineColorBlendStateCreateInfo Type;
+};
+
+// Map type VkPipelineDepthStencilStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkPipelineDepthStencilStateCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO> {
+    typedef VkPipelineDepthStencilStateCreateInfo Type;
+};
+
+// Map type VkPipelineDynamicStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkPipelineDynamicStateCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO> {
+    typedef VkPipelineDynamicStateCreateInfo Type;
+};
+
+// Map type VkPipelineInputAssemblyStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkPipelineInputAssemblyStateCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO> {
+    typedef VkPipelineInputAssemblyStateCreateInfo Type;
+};
+
+// Map type VkPipelineMultisampleStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkPipelineMultisampleStateCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO> {
+    typedef VkPipelineMultisampleStateCreateInfo Type;
+};
+
+// Map type VkPipelineRasterizationStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkPipelineRasterizationStateCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO> {
+    typedef VkPipelineRasterizationStateCreateInfo Type;
+};
+
+// Map type VkPipelineTessellationStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkPipelineTessellationStateCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO> {
+    typedef VkPipelineTessellationStateCreateInfo Type;
+};
+
+// Map type VkPipelineVertexInputStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkPipelineVertexInputStateCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO> {
+    typedef VkPipelineVertexInputStateCreateInfo Type;
+};
+
+// Map type VkPipelineViewportStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkPipelineViewportStateCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO> {
+    typedef VkPipelineViewportStateCreateInfo Type;
+};
+
+// Map type VkGraphicsPipelineCreateInfo to id VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkGraphicsPipelineCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO> {
+    typedef VkGraphicsPipelineCreateInfo Type;
+};
+
+// Map type VkFramebufferCreateInfo to id VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO
+template <>
+struct LvlTypeMap<VkFramebufferCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO> {
+    typedef VkFramebufferCreateInfo Type;
+};
+
+// Map type VkRenderPassCreateInfo to id VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO
+template <>
+struct LvlTypeMap<VkRenderPassCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO> {
+    typedef VkRenderPassCreateInfo Type;
+};
+
+// Map type VkRenderPassBeginInfo to id VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO
+template <>
+struct LvlTypeMap<VkRenderPassBeginInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO> {
+    typedef VkRenderPassBeginInfo Type;
+};
+
+// Map type VkBindBufferMemoryInfo to id VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO
+template <>
+struct LvlTypeMap<VkBindBufferMemoryInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO> {
+    typedef VkBindBufferMemoryInfo Type;
+};
+
+// Map type VkBindImageMemoryInfo to id VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO
+template <>
+struct LvlTypeMap<VkBindImageMemoryInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO> {
+    typedef VkBindImageMemoryInfo Type;
+};
+
+// Map type VkMemoryDedicatedRequirements to id VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS
+template <>
+struct LvlTypeMap<VkMemoryDedicatedRequirements> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS> {
+    typedef VkMemoryDedicatedRequirements Type;
+};
+
+// Map type VkMemoryDedicatedAllocateInfo to id VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO
+template <>
+struct LvlTypeMap<VkMemoryDedicatedAllocateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO> {
+    typedef VkMemoryDedicatedAllocateInfo Type;
+};
+
+// Map type VkMemoryAllocateFlagsInfo to id VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO
+template <>
+struct LvlTypeMap<VkMemoryAllocateFlagsInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO> {
+    typedef VkMemoryAllocateFlagsInfo Type;
+};
+
+// Map type VkDeviceGroupCommandBufferBeginInfo to id VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO
+template <>
+struct LvlTypeMap<VkDeviceGroupCommandBufferBeginInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO> {
+    typedef VkDeviceGroupCommandBufferBeginInfo Type;
+};
+
+// Map type VkDeviceGroupSubmitInfo to id VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO
+template <>
+struct LvlTypeMap<VkDeviceGroupSubmitInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO> {
+    typedef VkDeviceGroupSubmitInfo Type;
+};
+
+// Map type VkDeviceGroupBindSparseInfo to id VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO
+template <>
+struct LvlTypeMap<VkDeviceGroupBindSparseInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO> {
+    typedef VkDeviceGroupBindSparseInfo Type;
+};
+
+// Map type VkBindBufferMemoryDeviceGroupInfo to id VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO
+template <>
+struct LvlTypeMap<VkBindBufferMemoryDeviceGroupInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO> {
+    typedef VkBindBufferMemoryDeviceGroupInfo Type;
+};
+
+// Map type VkBindImageMemoryDeviceGroupInfo to id VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO
+template <>
+struct LvlTypeMap<VkBindImageMemoryDeviceGroupInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO> {
+    typedef VkBindImageMemoryDeviceGroupInfo Type;
+};
+
+// Map type VkPhysicalDeviceGroupProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceGroupProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES> {
+    typedef VkPhysicalDeviceGroupProperties Type;
+};
+
+// Map type VkDeviceGroupDeviceCreateInfo to id VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkDeviceGroupDeviceCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO> {
+    typedef VkDeviceGroupDeviceCreateInfo Type;
+};
+
+// Map type VkBufferMemoryRequirementsInfo2 to id VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2
+template <>
+struct LvlTypeMap<VkBufferMemoryRequirementsInfo2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2> {
+    typedef VkBufferMemoryRequirementsInfo2 Type;
+};
+
+// Map type VkImageMemoryRequirementsInfo2 to id VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2
+template <>
+struct LvlTypeMap<VkImageMemoryRequirementsInfo2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2> {
+    typedef VkImageMemoryRequirementsInfo2 Type;
+};
+
+// Map type VkImageSparseMemoryRequirementsInfo2 to id VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2
+template <>
+struct LvlTypeMap<VkImageSparseMemoryRequirementsInfo2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2> {
+    typedef VkImageSparseMemoryRequirementsInfo2 Type;
+};
+
+// Map type VkMemoryRequirements2 to id VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2
+template <>
+struct LvlTypeMap<VkMemoryRequirements2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2> {
+    typedef VkMemoryRequirements2 Type;
+};
+
+// Map type VkSparseImageMemoryRequirements2 to id VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2
+template <>
+struct LvlTypeMap<VkSparseImageMemoryRequirements2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2> {
+    typedef VkSparseImageMemoryRequirements2 Type;
+};
+
+// Map type VkPhysicalDeviceFeatures2 to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2
+template <>
+struct LvlTypeMap<VkPhysicalDeviceFeatures2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2> {
+    typedef VkPhysicalDeviceFeatures2 Type;
+};
+
+// Map type VkPhysicalDeviceProperties2 to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2
+template <>
+struct LvlTypeMap<VkPhysicalDeviceProperties2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2> {
+    typedef VkPhysicalDeviceProperties2 Type;
+};
+
+// Map type VkFormatProperties2 to id VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2
+template <>
+struct LvlTypeMap<VkFormatProperties2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2> {
+    typedef VkFormatProperties2 Type;
+};
+
+// Map type VkImageFormatProperties2 to id VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2
+template <>
+struct LvlTypeMap<VkImageFormatProperties2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2> {
+    typedef VkImageFormatProperties2 Type;
+};
+
+// Map type VkPhysicalDeviceImageFormatInfo2 to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2
+template <>
+struct LvlTypeMap<VkPhysicalDeviceImageFormatInfo2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2> {
+    typedef VkPhysicalDeviceImageFormatInfo2 Type;
+};
+
+// Map type VkQueueFamilyProperties2 to id VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2
+template <>
+struct LvlTypeMap<VkQueueFamilyProperties2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2> {
+    typedef VkQueueFamilyProperties2 Type;
+};
+
+// Map type VkPhysicalDeviceMemoryProperties2 to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMemoryProperties2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2> {
+    typedef VkPhysicalDeviceMemoryProperties2 Type;
+};
+
+// Map type VkSparseImageFormatProperties2 to id VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2
+template <>
+struct LvlTypeMap<VkSparseImageFormatProperties2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2> {
+    typedef VkSparseImageFormatProperties2 Type;
+};
+
+// Map type VkPhysicalDeviceSparseImageFormatInfo2 to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2
+template <>
+struct LvlTypeMap<VkPhysicalDeviceSparseImageFormatInfo2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2> {
+    typedef VkPhysicalDeviceSparseImageFormatInfo2 Type;
+};
+
+// Map type VkImageViewUsageCreateInfo to id VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkImageViewUsageCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO> {
+    typedef VkImageViewUsageCreateInfo Type;
+};
+
+// Map type VkPhysicalDeviceProtectedMemoryFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceProtectedMemoryFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES> {
+    typedef VkPhysicalDeviceProtectedMemoryFeatures Type;
+};
+
+// Map type VkPhysicalDeviceProtectedMemoryProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceProtectedMemoryProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES> {
+    typedef VkPhysicalDeviceProtectedMemoryProperties Type;
+};
+
+// Map type VkDeviceQueueInfo2 to id VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2
+template <>
+struct LvlTypeMap<VkDeviceQueueInfo2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2> {
+    typedef VkDeviceQueueInfo2 Type;
+};
+
+// Map type VkProtectedSubmitInfo to id VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO
+template <>
+struct LvlTypeMap<VkProtectedSubmitInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO> {
+    typedef VkProtectedSubmitInfo Type;
+};
+
+// Map type VkBindImagePlaneMemoryInfo to id VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO
+template <>
+struct LvlTypeMap<VkBindImagePlaneMemoryInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO> {
+    typedef VkBindImagePlaneMemoryInfo Type;
+};
+
+// Map type VkImagePlaneMemoryRequirementsInfo to id VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO
+template <>
+struct LvlTypeMap<VkImagePlaneMemoryRequirementsInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO> {
+    typedef VkImagePlaneMemoryRequirementsInfo Type;
+};
+
+// Map type VkPhysicalDeviceExternalImageFormatInfo to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO
+template <>
+struct LvlTypeMap<VkPhysicalDeviceExternalImageFormatInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO> {
+    typedef VkPhysicalDeviceExternalImageFormatInfo Type;
+};
+
+// Map type VkExternalImageFormatProperties to id VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES
+template <>
+struct LvlTypeMap<VkExternalImageFormatProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES> {
+    typedef VkExternalImageFormatProperties Type;
+};
+
+// Map type VkPhysicalDeviceExternalBufferInfo to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO
+template <>
+struct LvlTypeMap<VkPhysicalDeviceExternalBufferInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO> {
+    typedef VkPhysicalDeviceExternalBufferInfo Type;
+};
+
+// Map type VkExternalBufferProperties to id VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES
+template <>
+struct LvlTypeMap<VkExternalBufferProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES> {
+    typedef VkExternalBufferProperties Type;
+};
+
+// Map type VkPhysicalDeviceIDProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceIDProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES> {
+    typedef VkPhysicalDeviceIDProperties Type;
+};
+
+// Map type VkExternalMemoryImageCreateInfo to id VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkExternalMemoryImageCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO> {
+    typedef VkExternalMemoryImageCreateInfo Type;
+};
+
+// Map type VkExternalMemoryBufferCreateInfo to id VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO
+template <>
+struct LvlTypeMap<VkExternalMemoryBufferCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO> {
+    typedef VkExternalMemoryBufferCreateInfo Type;
+};
+
+// Map type VkExportMemoryAllocateInfo to id VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO
+template <>
+struct LvlTypeMap<VkExportMemoryAllocateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO> {
+    typedef VkExportMemoryAllocateInfo Type;
+};
+
+// Map type VkPhysicalDeviceExternalFenceInfo to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO
+template <>
+struct LvlTypeMap<VkPhysicalDeviceExternalFenceInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO> {
+    typedef VkPhysicalDeviceExternalFenceInfo Type;
+};
+
+// Map type VkExternalFenceProperties to id VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES
+template <>
+struct LvlTypeMap<VkExternalFenceProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES> {
+    typedef VkExternalFenceProperties Type;
+};
+
+// Map type VkExportFenceCreateInfo to id VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkExportFenceCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO> {
+    typedef VkExportFenceCreateInfo Type;
+};
+
+// Map type VkExportSemaphoreCreateInfo to id VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkExportSemaphoreCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO> {
+    typedef VkExportSemaphoreCreateInfo Type;
+};
+
+// Map type VkPhysicalDeviceExternalSemaphoreInfo to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO
+template <>
+struct LvlTypeMap<VkPhysicalDeviceExternalSemaphoreInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO> {
+    typedef VkPhysicalDeviceExternalSemaphoreInfo Type;
+};
+
+// Map type VkExternalSemaphoreProperties to id VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES
+template <>
+struct LvlTypeMap<VkExternalSemaphoreProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES> {
+    typedef VkExternalSemaphoreProperties Type;
+};
+
+// Map type VkPhysicalDeviceSubgroupProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceSubgroupProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES> {
+    typedef VkPhysicalDeviceSubgroupProperties Type;
+};
+
+// Map type VkPhysicalDevice16BitStorageFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDevice16BitStorageFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES> {
+    typedef VkPhysicalDevice16BitStorageFeatures Type;
+};
+
+// Map type VkPhysicalDeviceVariablePointersFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceVariablePointersFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES> {
+    typedef VkPhysicalDeviceVariablePointersFeatures Type;
+};
+
+// Map type VkDescriptorUpdateTemplateCreateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkDescriptorUpdateTemplateCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO> {
+    typedef VkDescriptorUpdateTemplateCreateInfo Type;
+};
+
+// Map type VkPhysicalDeviceMaintenance3Properties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMaintenance3Properties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES> {
+    typedef VkPhysicalDeviceMaintenance3Properties Type;
+};
+
+// Map type VkDescriptorSetLayoutSupport to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT
+template <>
+struct LvlTypeMap<VkDescriptorSetLayoutSupport> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT> {
+    typedef VkDescriptorSetLayoutSupport Type;
+};
+
+// Map type VkSamplerYcbcrConversionCreateInfo to id VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO
+template <>
+struct LvlTypeMap<VkSamplerYcbcrConversionCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO> {
+    typedef VkSamplerYcbcrConversionCreateInfo Type;
+};
+
+// Map type VkSamplerYcbcrConversionInfo to id VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO
+template <>
+struct LvlTypeMap<VkSamplerYcbcrConversionInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO> {
+    typedef VkSamplerYcbcrConversionInfo Type;
+};
+
+// Map type VkPhysicalDeviceSamplerYcbcrConversionFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceSamplerYcbcrConversionFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES> {
+    typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures Type;
+};
+
+// Map type VkSamplerYcbcrConversionImageFormatProperties to id VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES
+template <>
+struct LvlTypeMap<VkSamplerYcbcrConversionImageFormatProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES> {
+    typedef VkSamplerYcbcrConversionImageFormatProperties Type;
+};
+
+// Map type VkDeviceGroupRenderPassBeginInfo to id VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO
+template <>
+struct LvlTypeMap<VkDeviceGroupRenderPassBeginInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO> {
+    typedef VkDeviceGroupRenderPassBeginInfo Type;
+};
+
+// Map type VkPhysicalDevicePointClippingProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDevicePointClippingProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES> {
+    typedef VkPhysicalDevicePointClippingProperties Type;
+};
+
+// Map type VkRenderPassInputAttachmentAspectCreateInfo to id VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO
+template <>
+struct LvlTypeMap<VkRenderPassInputAttachmentAspectCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO> {
+    typedef VkRenderPassInputAttachmentAspectCreateInfo Type;
+};
+
+// Map type VkPipelineTessellationDomainOriginStateCreateInfo to id
+// VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkPipelineTessellationDomainOriginStateCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO> {
+    typedef VkPipelineTessellationDomainOriginStateCreateInfo Type;
+};
+
+// Map type VkRenderPassMultiviewCreateInfo to id VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO
+template <>
+struct LvlTypeMap<VkRenderPassMultiviewCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO> {
+    typedef VkRenderPassMultiviewCreateInfo Type;
+};
+
+// Map type VkPhysicalDeviceMultiviewFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMultiviewFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES> {
+    typedef VkPhysicalDeviceMultiviewFeatures Type;
+};
+
+// Map type VkPhysicalDeviceMultiviewProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMultiviewProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES> {
+    typedef VkPhysicalDeviceMultiviewProperties Type;
+};
+
+// Map type VkPhysicalDeviceShaderDrawParametersFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderDrawParametersFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES> {
+    typedef VkPhysicalDeviceShaderDrawParametersFeatures Type;
+};
+
+// Map type VkPhysicalDeviceDriverProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDriverProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES> {
+    typedef VkPhysicalDeviceDriverProperties Type;
+};
+
+// Map type VkPhysicalDeviceVulkan11Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceVulkan11Features> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES> {
+    typedef VkPhysicalDeviceVulkan11Features Type;
+};
+
+// Map type VkPhysicalDeviceVulkan11Properties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceVulkan11Properties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES> {
+    typedef VkPhysicalDeviceVulkan11Properties Type;
+};
+
+// Map type VkPhysicalDeviceVulkan12Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceVulkan12Features> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES> {
+    typedef VkPhysicalDeviceVulkan12Features Type;
+};
+
+// Map type VkPhysicalDeviceVulkan12Properties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceVulkan12Properties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES> {
+    typedef VkPhysicalDeviceVulkan12Properties Type;
+};
+
+// Map type VkImageFormatListCreateInfo to id VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO
+template <>
+struct LvlTypeMap<VkImageFormatListCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO> {
+    typedef VkImageFormatListCreateInfo Type;
+};
+
+// Map type VkPhysicalDeviceVulkanMemoryModelFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceVulkanMemoryModelFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES> {
+    typedef VkPhysicalDeviceVulkanMemoryModelFeatures Type;
+};
+
+// Map type VkPhysicalDeviceHostQueryResetFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceHostQueryResetFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES> {
+    typedef VkPhysicalDeviceHostQueryResetFeatures Type;
+};
+
+// Map type VkPhysicalDeviceTimelineSemaphoreFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceTimelineSemaphoreFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES> {
+    typedef VkPhysicalDeviceTimelineSemaphoreFeatures Type;
+};
+
+// Map type VkPhysicalDeviceTimelineSemaphoreProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceTimelineSemaphoreProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES> {
+    typedef VkPhysicalDeviceTimelineSemaphoreProperties Type;
+};
+
+// Map type VkSemaphoreTypeCreateInfo to id VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkSemaphoreTypeCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO> {
+    typedef VkSemaphoreTypeCreateInfo Type;
+};
+
+// Map type VkTimelineSemaphoreSubmitInfo to id VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO
+template <>
+struct LvlTypeMap<VkTimelineSemaphoreSubmitInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO> {
+    typedef VkTimelineSemaphoreSubmitInfo Type;
+};
+
+// Map type VkSemaphoreWaitInfo to id VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO
+template <>
+struct LvlTypeMap<VkSemaphoreWaitInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO> {
+    typedef VkSemaphoreWaitInfo Type;
+};
+
+// Map type VkSemaphoreSignalInfo to id VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO
+template <>
+struct LvlTypeMap<VkSemaphoreSignalInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO> {
+    typedef VkSemaphoreSignalInfo Type;
+};
+
+// Map type VkPhysicalDeviceBufferDeviceAddressFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceBufferDeviceAddressFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES> {
+    typedef VkPhysicalDeviceBufferDeviceAddressFeatures Type;
+};
+
+// Map type VkBufferDeviceAddressInfo to id VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO
+template <>
+struct LvlTypeMap<VkBufferDeviceAddressInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO> {
+    typedef VkBufferDeviceAddressInfo Type;
+};
+
+// Map type VkBufferOpaqueCaptureAddressCreateInfo to id VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO
+template <>
+struct LvlTypeMap<VkBufferOpaqueCaptureAddressCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO> {
+    typedef VkBufferOpaqueCaptureAddressCreateInfo Type;
+};
+
+// Map type VkMemoryOpaqueCaptureAddressAllocateInfo to id VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO
+template <>
+struct LvlTypeMap<VkMemoryOpaqueCaptureAddressAllocateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO> {
+    typedef VkMemoryOpaqueCaptureAddressAllocateInfo Type;
+};
+
+// Map type VkDeviceMemoryOpaqueCaptureAddressInfo to id VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO
+template <>
+struct LvlTypeMap<VkDeviceMemoryOpaqueCaptureAddressInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO> {
+    typedef VkDeviceMemoryOpaqueCaptureAddressInfo Type;
+};
+
+// Map type VkPhysicalDevice8BitStorageFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDevice8BitStorageFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES> {
+    typedef VkPhysicalDevice8BitStorageFeatures Type;
+};
+
+// Map type VkPhysicalDeviceShaderAtomicInt64Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderAtomicInt64Features> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES> {
+    typedef VkPhysicalDeviceShaderAtomicInt64Features Type;
+};
+
+// Map type VkPhysicalDeviceShaderFloat16Int8Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderFloat16Int8Features> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES> {
+    typedef VkPhysicalDeviceShaderFloat16Int8Features Type;
+};
+
+// Map type VkPhysicalDeviceFloatControlsProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceFloatControlsProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES> {
+    typedef VkPhysicalDeviceFloatControlsProperties Type;
+};
+
+// Map type VkDescriptorSetLayoutBindingFlagsCreateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO
+template <>
+struct LvlTypeMap<VkDescriptorSetLayoutBindingFlagsCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO> {
+    typedef VkDescriptorSetLayoutBindingFlagsCreateInfo Type;
+};
+
+// Map type VkPhysicalDeviceDescriptorIndexingFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDescriptorIndexingFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES> {
+    typedef VkPhysicalDeviceDescriptorIndexingFeatures Type;
+};
+
+// Map type VkPhysicalDeviceDescriptorIndexingProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDescriptorIndexingProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES> {
+    typedef VkPhysicalDeviceDescriptorIndexingProperties Type;
+};
+
+// Map type VkDescriptorSetVariableDescriptorCountAllocateInfo to id
+// VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO
+template <>
+struct LvlTypeMap<VkDescriptorSetVariableDescriptorCountAllocateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO> {
+    typedef VkDescriptorSetVariableDescriptorCountAllocateInfo Type;
+};
+
+// Map type VkDescriptorSetVariableDescriptorCountLayoutSupport to id
+// VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT
+template <>
+struct LvlTypeMap<VkDescriptorSetVariableDescriptorCountLayoutSupport> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT> {
+    typedef VkDescriptorSetVariableDescriptorCountLayoutSupport Type;
+};
+
+// Map type VkPhysicalDeviceScalarBlockLayoutFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceScalarBlockLayoutFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES> {
+    typedef VkPhysicalDeviceScalarBlockLayoutFeatures Type;
+};
+
+// Map type VkSamplerReductionModeCreateInfo to id VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkSamplerReductionModeCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO> {
+    typedef VkSamplerReductionModeCreateInfo Type;
+};
+
+// Map type VkPhysicalDeviceSamplerFilterMinmaxProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceSamplerFilterMinmaxProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES> {
+    typedef VkPhysicalDeviceSamplerFilterMinmaxProperties Type;
+};
+
+// Map type VkPhysicalDeviceUniformBufferStandardLayoutFeatures to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceUniformBufferStandardLayoutFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES> {
+    typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures Type;
+};
+
+// Map type VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES> {
+    typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures Type;
+};
+
+// Map type VkAttachmentDescription2 to id VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2
+template <>
+struct LvlTypeMap<VkAttachmentDescription2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2> {
+    typedef VkAttachmentDescription2 Type;
+};
+
+// Map type VkAttachmentReference2 to id VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2
+template <>
+struct LvlTypeMap<VkAttachmentReference2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2> {
+    typedef VkAttachmentReference2 Type;
+};
+
+// Map type VkSubpassDescription2 to id VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2
+template <>
+struct LvlTypeMap<VkSubpassDescription2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2> {
+    typedef VkSubpassDescription2 Type;
+};
+
+// Map type VkSubpassDependency2 to id VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2
+template <>
+struct LvlTypeMap<VkSubpassDependency2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2> {
+    typedef VkSubpassDependency2 Type;
+};
+
+// Map type VkSubpassBeginInfo to id VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO
+template <>
+struct LvlTypeMap<VkSubpassBeginInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO> {
+    typedef VkSubpassBeginInfo Type;
+};
+
+// Map type VkSubpassEndInfo to id VK_STRUCTURE_TYPE_SUBPASS_END_INFO
+template <>
+struct LvlTypeMap<VkSubpassEndInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_END_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBPASS_END_INFO> {
+    typedef VkSubpassEndInfo Type;
+};
+
+// Map type VkRenderPassCreateInfo2 to id VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2
+template <>
+struct LvlTypeMap<VkRenderPassCreateInfo2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2> {
+    typedef VkRenderPassCreateInfo2 Type;
+};
+
+// Map type VkSubpassDescriptionDepthStencilResolve to id VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE
+template <>
+struct LvlTypeMap<VkSubpassDescriptionDepthStencilResolve> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE> {
+    typedef VkSubpassDescriptionDepthStencilResolve Type;
+};
+
+// Map type VkPhysicalDeviceDepthStencilResolveProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDepthStencilResolveProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES> {
+    typedef VkPhysicalDeviceDepthStencilResolveProperties Type;
+};
+
+// Map type VkImageStencilUsageCreateInfo to id VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkImageStencilUsageCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO> {
+    typedef VkImageStencilUsageCreateInfo Type;
+};
+
+// Map type VkPhysicalDeviceImagelessFramebufferFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceImagelessFramebufferFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES> {
+    typedef VkPhysicalDeviceImagelessFramebufferFeatures Type;
+};
+
+// Map type VkFramebufferAttachmentImageInfo to id VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO
+template <>
+struct LvlTypeMap<VkFramebufferAttachmentImageInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO> {
+    typedef VkFramebufferAttachmentImageInfo Type;
+};
+
+// Map type VkRenderPassAttachmentBeginInfo to id VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO
+template <>
+struct LvlTypeMap<VkRenderPassAttachmentBeginInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO> {
+    typedef VkRenderPassAttachmentBeginInfo Type;
+};
+
+// Map type VkFramebufferAttachmentsCreateInfo to id VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO
+template <>
+struct LvlTypeMap<VkFramebufferAttachmentsCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO> {
+    typedef VkFramebufferAttachmentsCreateInfo Type;
+};
+
+// Map type VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES> {
+    typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures Type;
+};
+
+// Map type VkAttachmentReferenceStencilLayout to id VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT
+template <>
+struct LvlTypeMap<VkAttachmentReferenceStencilLayout> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT> {
+    typedef VkAttachmentReferenceStencilLayout Type;
+};
+
+// Map type VkAttachmentDescriptionStencilLayout to id VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT
+template <>
+struct LvlTypeMap<VkAttachmentDescriptionStencilLayout> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT> {
+    typedef VkAttachmentDescriptionStencilLayout Type;
+};
+
+// Map type VkPhysicalDeviceVulkan13Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceVulkan13Features> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES> {
+    typedef VkPhysicalDeviceVulkan13Features Type;
+};
+
+// Map type VkPhysicalDeviceVulkan13Properties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceVulkan13Properties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES> {
+    typedef VkPhysicalDeviceVulkan13Properties Type;
+};
+
+// Map type VkPhysicalDeviceToolProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceToolProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES> {
+    typedef VkPhysicalDeviceToolProperties Type;
+};
+
+// Map type VkPhysicalDevicePrivateDataFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDevicePrivateDataFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES> {
+    typedef VkPhysicalDevicePrivateDataFeatures Type;
+};
+
+// Map type VkDevicePrivateDataCreateInfo to id VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO
+template <>
+struct LvlTypeMap<VkDevicePrivateDataCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO> {
+    typedef VkDevicePrivateDataCreateInfo Type;
+};
+
+// Map type VkPrivateDataSlotCreateInfo to id VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO
+template <>
+struct LvlTypeMap<VkPrivateDataSlotCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO> {
+    typedef VkPrivateDataSlotCreateInfo Type;
+};
+
+// Map type VkMemoryBarrier2 to id VK_STRUCTURE_TYPE_MEMORY_BARRIER_2
+template <>
+struct LvlTypeMap<VkMemoryBarrier2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_BARRIER_2> {
+    typedef VkMemoryBarrier2 Type;
+};
+
+// Map type VkBufferMemoryBarrier2 to id VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2
+template <>
+struct LvlTypeMap<VkBufferMemoryBarrier2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2> {
+    typedef VkBufferMemoryBarrier2 Type;
+};
+
+// Map type VkImageMemoryBarrier2 to id VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2
+template <>
+struct LvlTypeMap<VkImageMemoryBarrier2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2> {
+    typedef VkImageMemoryBarrier2 Type;
+};
+
+// Map type VkDependencyInfo to id VK_STRUCTURE_TYPE_DEPENDENCY_INFO
+template <>
+struct LvlTypeMap<VkDependencyInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEPENDENCY_INFO> {
+    typedef VkDependencyInfo Type;
+};
+
+// Map type VkSemaphoreSubmitInfo to id VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO
+template <>
+struct LvlTypeMap<VkSemaphoreSubmitInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO> {
+    typedef VkSemaphoreSubmitInfo Type;
+};
+
+// Map type VkCommandBufferSubmitInfo to id VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO
+template <>
+struct LvlTypeMap<VkCommandBufferSubmitInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO> {
+    typedef VkCommandBufferSubmitInfo Type;
+};
+
+// Map type VkSubmitInfo2 to id VK_STRUCTURE_TYPE_SUBMIT_INFO_2
+template <>
+struct LvlTypeMap<VkSubmitInfo2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBMIT_INFO_2> {
+    typedef VkSubmitInfo2 Type;
+};
+
+// Map type VkPhysicalDeviceSynchronization2Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceSynchronization2Features> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES> {
+    typedef VkPhysicalDeviceSynchronization2Features Type;
+};
+
+// Map type VkBufferCopy2 to id VK_STRUCTURE_TYPE_BUFFER_COPY_2
+template <>
+struct LvlTypeMap<VkBufferCopy2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_COPY_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_COPY_2> {
+    typedef VkBufferCopy2 Type;
+};
+
+// Map type VkCopyBufferInfo2 to id VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2
+template <>
+struct LvlTypeMap<VkCopyBufferInfo2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2> {
+    typedef VkCopyBufferInfo2 Type;
+};
+
+// Map type VkImageCopy2 to id VK_STRUCTURE_TYPE_IMAGE_COPY_2
+template <>
+struct LvlTypeMap<VkImageCopy2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_COPY_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_COPY_2> {
+    typedef VkImageCopy2 Type;
+};
+
+// Map type VkCopyImageInfo2 to id VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2
+template <>
+struct LvlTypeMap<VkCopyImageInfo2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2> {
+    typedef VkCopyImageInfo2 Type;
+};
+
+// Map type VkBufferImageCopy2 to id VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2
+template <>
+struct LvlTypeMap<VkBufferImageCopy2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2> {
+    typedef VkBufferImageCopy2 Type;
+};
+
+// Map type VkCopyBufferToImageInfo2 to id VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2
+template <>
+struct LvlTypeMap<VkCopyBufferToImageInfo2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2> {
+    typedef VkCopyBufferToImageInfo2 Type;
+};
+
+// Map type VkCopyImageToBufferInfo2 to id VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2
+template <>
+struct LvlTypeMap<VkCopyImageToBufferInfo2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2> {
+    typedef VkCopyImageToBufferInfo2 Type;
+};
+
+// Map type VkPhysicalDeviceTextureCompressionASTCHDRFeatures to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceTextureCompressionASTCHDRFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES> {
+    typedef VkPhysicalDeviceTextureCompressionASTCHDRFeatures Type;
+};
+
+// Map type VkFormatProperties3 to id VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3
+template <>
+struct LvlTypeMap<VkFormatProperties3> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3> {
+    typedef VkFormatProperties3 Type;
+};
+
+// Map type VkPhysicalDeviceMaintenance4Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMaintenance4Features> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES> {
+    typedef VkPhysicalDeviceMaintenance4Features Type;
+};
+
+// Map type VkPhysicalDeviceMaintenance4Properties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMaintenance4Properties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES> {
+    typedef VkPhysicalDeviceMaintenance4Properties Type;
+};
+
+// Map type VkDeviceBufferMemoryRequirements to id VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS
+template <>
+struct LvlTypeMap<VkDeviceBufferMemoryRequirements> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS> {
+    typedef VkDeviceBufferMemoryRequirements Type;
+};
+
+// Map type VkDeviceImageMemoryRequirements to id VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS
+template <>
+struct LvlTypeMap<VkDeviceImageMemoryRequirements> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS> {
+    typedef VkDeviceImageMemoryRequirements Type;
+};
+
+// Map type VkPipelineCreationFeedbackCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO
+template <>
+struct LvlTypeMap<VkPipelineCreationFeedbackCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO> {
+    typedef VkPipelineCreationFeedbackCreateInfo Type;
+};
+
+// Map type VkPhysicalDeviceShaderTerminateInvocationFeatures to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderTerminateInvocationFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES> {
+    typedef VkPhysicalDeviceShaderTerminateInvocationFeatures Type;
+};
+
+// Map type VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES> {
+    typedef VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures Type;
+};
+
+// Map type VkPhysicalDevicePipelineCreationCacheControlFeatures to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDevicePipelineCreationCacheControlFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES> {
+    typedef VkPhysicalDevicePipelineCreationCacheControlFeatures Type;
+};
+
+// Map type VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES> {
+    typedef VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures Type;
+};
+
+// Map type VkPhysicalDeviceImageRobustnessFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceImageRobustnessFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES> {
+    typedef VkPhysicalDeviceImageRobustnessFeatures Type;
+};
+
+// Map type VkPhysicalDeviceSubgroupSizeControlFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceSubgroupSizeControlFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES> {
+    typedef VkPhysicalDeviceSubgroupSizeControlFeatures Type;
+};
+
+// Map type VkPhysicalDeviceSubgroupSizeControlProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceSubgroupSizeControlProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES> {
+    typedef VkPhysicalDeviceSubgroupSizeControlProperties Type;
+};
+
+// Map type VkPipelineShaderStageRequiredSubgroupSizeCreateInfo to id
+// VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkPipelineShaderStageRequiredSubgroupSizeCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO> {
+    typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo Type;
+};
+
+// Map type VkPhysicalDeviceInlineUniformBlockFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceInlineUniformBlockFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES> {
+    typedef VkPhysicalDeviceInlineUniformBlockFeatures Type;
+};
+
+// Map type VkPhysicalDeviceInlineUniformBlockProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceInlineUniformBlockProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES> {
+    typedef VkPhysicalDeviceInlineUniformBlockProperties Type;
+};
+
+// Map type VkWriteDescriptorSetInlineUniformBlock to id VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK
+template <>
+struct LvlTypeMap<VkWriteDescriptorSetInlineUniformBlock> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK> {
+    typedef VkWriteDescriptorSetInlineUniformBlock Type;
+};
+
+// Map type VkDescriptorPoolInlineUniformBlockCreateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO
+template <>
+struct LvlTypeMap<VkDescriptorPoolInlineUniformBlockCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO> {
+    typedef VkDescriptorPoolInlineUniformBlockCreateInfo Type;
+};
+
+// Map type VkPhysicalDeviceShaderIntegerDotProductFeatures to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderIntegerDotProductFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES> {
+    typedef VkPhysicalDeviceShaderIntegerDotProductFeatures Type;
+};
+
+// Map type VkPhysicalDeviceShaderIntegerDotProductProperties to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderIntegerDotProductProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES> {
+    typedef VkPhysicalDeviceShaderIntegerDotProductProperties Type;
+};
+
+// Map type VkPhysicalDeviceTexelBufferAlignmentProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceTexelBufferAlignmentProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES> {
+    typedef VkPhysicalDeviceTexelBufferAlignmentProperties Type;
+};
+
+// Map type VkImageBlit2 to id VK_STRUCTURE_TYPE_IMAGE_BLIT_2
+template <>
+struct LvlTypeMap<VkImageBlit2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_BLIT_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_BLIT_2> {
+    typedef VkImageBlit2 Type;
+};
+
+// Map type VkBlitImageInfo2 to id VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2
+template <>
+struct LvlTypeMap<VkBlitImageInfo2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2> {
+    typedef VkBlitImageInfo2 Type;
+};
+
+// Map type VkImageResolve2 to id VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2
+template <>
+struct LvlTypeMap<VkImageResolve2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2> {
+    typedef VkImageResolve2 Type;
+};
+
+// Map type VkResolveImageInfo2 to id VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2
+template <>
+struct LvlTypeMap<VkResolveImageInfo2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2> {
+    typedef VkResolveImageInfo2 Type;
+};
+
+// Map type VkRenderingAttachmentInfo to id VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO
+template <>
+struct LvlTypeMap<VkRenderingAttachmentInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO> {
+    typedef VkRenderingAttachmentInfo Type;
+};
+
+// Map type VkRenderingInfo to id VK_STRUCTURE_TYPE_RENDERING_INFO
+template <>
+struct LvlTypeMap<VkRenderingInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_INFO> {
+    typedef VkRenderingInfo Type;
+};
+
+// Map type VkPipelineRenderingCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO
+template <>
+struct LvlTypeMap<VkPipelineRenderingCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO> {
+    typedef VkPipelineRenderingCreateInfo Type;
+};
+
+// Map type VkPhysicalDeviceDynamicRenderingFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDynamicRenderingFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES> {
+    typedef VkPhysicalDeviceDynamicRenderingFeatures Type;
+};
+
+// Map type VkCommandBufferInheritanceRenderingInfo to id VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO
+template <>
+struct LvlTypeMap<VkCommandBufferInheritanceRenderingInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO> {
+    typedef VkCommandBufferInheritanceRenderingInfo Type;
+};
+
+// Map type VkPhysicalDeviceVulkan14Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceVulkan14Features> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES> {
+    typedef VkPhysicalDeviceVulkan14Features Type;
+};
+
+// Map type VkPhysicalDeviceVulkan14Properties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceVulkan14Properties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES> {
+    typedef VkPhysicalDeviceVulkan14Properties Type;
+};
+
+// Map type VkDeviceQueueGlobalPriorityCreateInfo to id VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO
+template <>
+struct LvlTypeMap<VkDeviceQueueGlobalPriorityCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO> {
+    typedef VkDeviceQueueGlobalPriorityCreateInfo Type;
+};
+
+// Map type VkPhysicalDeviceGlobalPriorityQueryFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceGlobalPriorityQueryFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES> {
+    typedef VkPhysicalDeviceGlobalPriorityQueryFeatures Type;
+};
+
+// Map type VkQueueFamilyGlobalPriorityProperties to id VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES
+template <>
+struct LvlTypeMap<VkQueueFamilyGlobalPriorityProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES> {
+    typedef VkQueueFamilyGlobalPriorityProperties Type;
+};
+
+// Map type VkPhysicalDeviceIndexTypeUint8Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceIndexTypeUint8Features> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES> {
+    typedef VkPhysicalDeviceIndexTypeUint8Features Type;
+};
+
+// Map type VkMemoryMapInfo to id VK_STRUCTURE_TYPE_MEMORY_MAP_INFO
+template <>
+struct LvlTypeMap<VkMemoryMapInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_MAP_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_MAP_INFO> {
+    typedef VkMemoryMapInfo Type;
+};
+
+// Map type VkMemoryUnmapInfo to id VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO
+template <>
+struct LvlTypeMap<VkMemoryUnmapInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO> {
+    typedef VkMemoryUnmapInfo Type;
+};
+
+// Map type VkPhysicalDeviceMaintenance5Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMaintenance5Features> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES> {
+    typedef VkPhysicalDeviceMaintenance5Features Type;
+};
+
+// Map type VkPhysicalDeviceMaintenance5Properties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMaintenance5Properties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES> {
+    typedef VkPhysicalDeviceMaintenance5Properties Type;
+};
+
+// Map type VkSubresourceLayout2 to id VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2
+template <>
+struct LvlTypeMap<VkSubresourceLayout2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2> {
+    typedef VkSubresourceLayout2 Type;
+};
+
+// Map type VkImageSubresource2 to id VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2
+template <>
+struct LvlTypeMap<VkImageSubresource2> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2> {
+    typedef VkImageSubresource2 Type;
+};
+
+// Map type VkDeviceImageSubresourceInfo to id VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO
+template <>
+struct LvlTypeMap<VkDeviceImageSubresourceInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO> {
+    typedef VkDeviceImageSubresourceInfo Type;
+};
+
+// Map type VkBufferUsageFlags2CreateInfo to id VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO
+template <>
+struct LvlTypeMap<VkBufferUsageFlags2CreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO> {
+    typedef VkBufferUsageFlags2CreateInfo Type;
+};
+
+// Map type VkPhysicalDeviceMaintenance6Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMaintenance6Features> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES> {
+    typedef VkPhysicalDeviceMaintenance6Features Type;
+};
+
+// Map type VkPhysicalDeviceMaintenance6Properties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMaintenance6Properties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES> {
+    typedef VkPhysicalDeviceMaintenance6Properties Type;
+};
+
+// Map type VkBindMemoryStatus to id VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS
+template <>
+struct LvlTypeMap<VkBindMemoryStatus> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS> {
+    typedef VkBindMemoryStatus Type;
+};
+
+// Map type VkPhysicalDeviceHostImageCopyFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceHostImageCopyFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES> {
+    typedef VkPhysicalDeviceHostImageCopyFeatures Type;
+};
+
+// Map type VkPhysicalDeviceHostImageCopyProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceHostImageCopyProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES> {
+    typedef VkPhysicalDeviceHostImageCopyProperties Type;
+};
+
+// Map type VkMemoryToImageCopy to id VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY
+template <>
+struct LvlTypeMap<VkMemoryToImageCopy> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY> {
+    typedef VkMemoryToImageCopy Type;
+};
+
+// Map type VkImageToMemoryCopy to id VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY
+template <>
+struct LvlTypeMap<VkImageToMemoryCopy> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY> {
+    typedef VkImageToMemoryCopy Type;
+};
+
+// Map type VkCopyMemoryToImageInfo to id VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO
+template <>
+struct LvlTypeMap<VkCopyMemoryToImageInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO> {
+    typedef VkCopyMemoryToImageInfo Type;
+};
+
+// Map type VkCopyImageToMemoryInfo to id VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO
+template <>
+struct LvlTypeMap<VkCopyImageToMemoryInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO> {
+    typedef VkCopyImageToMemoryInfo Type;
+};
+
+// Map type VkCopyImageToImageInfo to id VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO
+template <>
+struct LvlTypeMap<VkCopyImageToImageInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO> {
+    typedef VkCopyImageToImageInfo Type;
+};
+
+// Map type VkHostImageLayoutTransitionInfo to id VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO
+template <>
+struct LvlTypeMap<VkHostImageLayoutTransitionInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO> {
+    typedef VkHostImageLayoutTransitionInfo Type;
+};
+
+// Map type VkSubresourceHostMemcpySize to id VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE
+template <>
+struct LvlTypeMap<VkSubresourceHostMemcpySize> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE> {
+    typedef VkSubresourceHostMemcpySize Type;
+};
+
+// Map type VkHostImageCopyDevicePerformanceQuery to id VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY
+template <>
+struct LvlTypeMap<VkHostImageCopyDevicePerformanceQuery> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY> {
+    typedef VkHostImageCopyDevicePerformanceQuery Type;
+};
+
+// Map type VkPhysicalDeviceShaderSubgroupRotateFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderSubgroupRotateFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES> {
+    typedef VkPhysicalDeviceShaderSubgroupRotateFeatures Type;
+};
+
+// Map type VkPhysicalDeviceShaderFloatControls2Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderFloatControls2Features> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES> {
+    typedef VkPhysicalDeviceShaderFloatControls2Features Type;
+};
+
+// Map type VkPhysicalDeviceShaderExpectAssumeFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderExpectAssumeFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES> {
+    typedef VkPhysicalDeviceShaderExpectAssumeFeatures Type;
+};
+
+// Map type VkPipelineCreateFlags2CreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO
+template <>
+struct LvlTypeMap<VkPipelineCreateFlags2CreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO> {
+    typedef VkPipelineCreateFlags2CreateInfo Type;
+};
+
+// Map type VkPhysicalDevicePushDescriptorProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDevicePushDescriptorProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES> {
+    typedef VkPhysicalDevicePushDescriptorProperties Type;
+};
+
+// Map type VkBindDescriptorSetsInfo to id VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO
+template <>
+struct LvlTypeMap<VkBindDescriptorSetsInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO> {
+    typedef VkBindDescriptorSetsInfo Type;
+};
+
+// Map type VkPushConstantsInfo to id VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO
+template <>
+struct LvlTypeMap<VkPushConstantsInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO> {
+    typedef VkPushConstantsInfo Type;
+};
+
+// Map type VkPushDescriptorSetInfo to id VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO
+template <>
+struct LvlTypeMap<VkPushDescriptorSetInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO> {
+    typedef VkPushDescriptorSetInfo Type;
+};
+
+// Map type VkPushDescriptorSetWithTemplateInfo to id VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO
+template <>
+struct LvlTypeMap<VkPushDescriptorSetWithTemplateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO> {
+    typedef VkPushDescriptorSetWithTemplateInfo Type;
+};
+
+// Map type VkPhysicalDevicePipelineProtectedAccessFeatures to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDevicePipelineProtectedAccessFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES> {
+    typedef VkPhysicalDevicePipelineProtectedAccessFeatures Type;
+};
+
+// Map type VkPhysicalDevicePipelineRobustnessFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDevicePipelineRobustnessFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES> {
+    typedef VkPhysicalDevicePipelineRobustnessFeatures Type;
+};
+
+// Map type VkPhysicalDevicePipelineRobustnessProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDevicePipelineRobustnessProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES> {
+    typedef VkPhysicalDevicePipelineRobustnessProperties Type;
+};
+
+// Map type VkPipelineRobustnessCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO
+template <>
+struct LvlTypeMap<VkPipelineRobustnessCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO> {
+    typedef VkPipelineRobustnessCreateInfo Type;
+};
+
+// Map type VkPhysicalDeviceLineRasterizationFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceLineRasterizationFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES> {
+    typedef VkPhysicalDeviceLineRasterizationFeatures Type;
+};
+
+// Map type VkPhysicalDeviceLineRasterizationProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceLineRasterizationProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES> {
+    typedef VkPhysicalDeviceLineRasterizationProperties Type;
+};
+
+// Map type VkPipelineRasterizationLineStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkPipelineRasterizationLineStateCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO> {
+    typedef VkPipelineRasterizationLineStateCreateInfo Type;
+};
+
+// Map type VkPhysicalDeviceVertexAttributeDivisorProperties to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceVertexAttributeDivisorProperties> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES> {
+    typedef VkPhysicalDeviceVertexAttributeDivisorProperties Type;
+};
+
+// Map type VkPipelineVertexInputDivisorStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO
+template <>
+struct LvlTypeMap<VkPipelineVertexInputDivisorStateCreateInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO> {
+    typedef VkPipelineVertexInputDivisorStateCreateInfo Type;
+};
+
+// Map type VkPhysicalDeviceVertexAttributeDivisorFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceVertexAttributeDivisorFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES> {
+    typedef VkPhysicalDeviceVertexAttributeDivisorFeatures Type;
+};
+
+// Map type VkRenderingAreaInfo to id VK_STRUCTURE_TYPE_RENDERING_AREA_INFO
+template <>
+struct LvlTypeMap<VkRenderingAreaInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_AREA_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_AREA_INFO> {
+    typedef VkRenderingAreaInfo Type;
+};
+
+// Map type VkPhysicalDeviceDynamicRenderingLocalReadFeatures to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDynamicRenderingLocalReadFeatures> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES> {
+    typedef VkPhysicalDeviceDynamicRenderingLocalReadFeatures Type;
+};
+
+// Map type VkRenderingAttachmentLocationInfo to id VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO
+template <>
+struct LvlTypeMap<VkRenderingAttachmentLocationInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO> {
+    typedef VkRenderingAttachmentLocationInfo Type;
+};
+
+// Map type VkRenderingInputAttachmentIndexInfo to id VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO
+template <>
+struct LvlTypeMap<VkRenderingInputAttachmentIndexInfo> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO> {
+    typedef VkRenderingInputAttachmentIndexInfo Type;
+};
+
+// Map type VkSwapchainCreateInfoKHR to id VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkSwapchainCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR> {
+    typedef VkSwapchainCreateInfoKHR Type;
+};
+
+// Map type VkPresentInfoKHR to id VK_STRUCTURE_TYPE_PRESENT_INFO_KHR
+template <>
+struct LvlTypeMap<VkPresentInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_INFO_KHR> {
+    typedef VkPresentInfoKHR Type;
+};
+
+// Map type VkImageSwapchainCreateInfoKHR to id VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkImageSwapchainCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR> {
+    typedef VkImageSwapchainCreateInfoKHR Type;
+};
+
+// Map type VkBindImageMemorySwapchainInfoKHR to id VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR
+template <>
+struct LvlTypeMap<VkBindImageMemorySwapchainInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR> {
+    typedef VkBindImageMemorySwapchainInfoKHR Type;
+};
+
+// Map type VkAcquireNextImageInfoKHR to id VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR
+template <>
+struct LvlTypeMap<VkAcquireNextImageInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR> {
+    typedef VkAcquireNextImageInfoKHR Type;
+};
+
+// Map type VkDeviceGroupPresentCapabilitiesKHR to id VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR
+template <>
+struct LvlTypeMap<VkDeviceGroupPresentCapabilitiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR> {
+    typedef VkDeviceGroupPresentCapabilitiesKHR Type;
+};
+
+// Map type VkDeviceGroupPresentInfoKHR to id VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR
+template <>
+struct LvlTypeMap<VkDeviceGroupPresentInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR> {
+    typedef VkDeviceGroupPresentInfoKHR Type;
+};
+
+// Map type VkDeviceGroupSwapchainCreateInfoKHR to id VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkDeviceGroupSwapchainCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR> {
+    typedef VkDeviceGroupSwapchainCreateInfoKHR Type;
+};
+
+// Map type VkDisplayModeCreateInfoKHR to id VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkDisplayModeCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR> {
+    typedef VkDisplayModeCreateInfoKHR Type;
+};
+
+// Map type VkDisplaySurfaceCreateInfoKHR to id VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkDisplaySurfaceCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR> {
+    typedef VkDisplaySurfaceCreateInfoKHR Type;
+};
+
+// Map type VkDisplayPresentInfoKHR to id VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR
+template <>
+struct LvlTypeMap<VkDisplayPresentInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR> {
+    typedef VkDisplayPresentInfoKHR Type;
+};
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+// Map type VkXlibSurfaceCreateInfoKHR to id VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkXlibSurfaceCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR> {
+    typedef VkXlibSurfaceCreateInfoKHR Type;
+};
+
+#endif  // VK_USE_PLATFORM_XLIB_KHR
+#ifdef VK_USE_PLATFORM_XCB_KHR
+// Map type VkXcbSurfaceCreateInfoKHR to id VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkXcbSurfaceCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR> {
+    typedef VkXcbSurfaceCreateInfoKHR Type;
+};
+
+#endif  // VK_USE_PLATFORM_XCB_KHR
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+// Map type VkWaylandSurfaceCreateInfoKHR to id VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkWaylandSurfaceCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR> {
+    typedef VkWaylandSurfaceCreateInfoKHR Type;
+};
+
+#endif  // VK_USE_PLATFORM_WAYLAND_KHR
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+// Map type VkAndroidSurfaceCreateInfoKHR to id VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkAndroidSurfaceCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR> {
+    typedef VkAndroidSurfaceCreateInfoKHR Type;
+};
+
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+// Map type VkWin32SurfaceCreateInfoKHR to id VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkWin32SurfaceCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR> {
+    typedef VkWin32SurfaceCreateInfoKHR Type;
+};
+
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+// Map type VkQueueFamilyQueryResultStatusPropertiesKHR to id VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkQueueFamilyQueryResultStatusPropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR> {
+    typedef VkQueueFamilyQueryResultStatusPropertiesKHR Type;
+};
+
+// Map type VkQueueFamilyVideoPropertiesKHR to id VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkQueueFamilyVideoPropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR> {
+    typedef VkQueueFamilyVideoPropertiesKHR Type;
+};
+
+// Map type VkVideoProfileInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoProfileInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR> {
+    typedef VkVideoProfileInfoKHR Type;
+};
+
+// Map type VkVideoProfileListInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoProfileListInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR> {
+    typedef VkVideoProfileListInfoKHR Type;
+};
+
+// Map type VkVideoCapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR
+template <>
+struct LvlTypeMap<VkVideoCapabilitiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR> {
+    typedef VkVideoCapabilitiesKHR Type;
+};
+
+// Map type VkPhysicalDeviceVideoFormatInfoKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceVideoFormatInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR> {
+    typedef VkPhysicalDeviceVideoFormatInfoKHR Type;
+};
+
+// Map type VkVideoFormatPropertiesKHR to id VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkVideoFormatPropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR> {
+    typedef VkVideoFormatPropertiesKHR Type;
+};
+
+// Map type VkVideoPictureResourceInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoPictureResourceInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR> {
+    typedef VkVideoPictureResourceInfoKHR Type;
+};
+
+// Map type VkVideoReferenceSlotInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoReferenceSlotInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR> {
+    typedef VkVideoReferenceSlotInfoKHR Type;
+};
+
+// Map type VkVideoSessionMemoryRequirementsKHR to id VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR
+template <>
+struct LvlTypeMap<VkVideoSessionMemoryRequirementsKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR> {
+    typedef VkVideoSessionMemoryRequirementsKHR Type;
+};
+
+// Map type VkBindVideoSessionMemoryInfoKHR to id VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR
+template <>
+struct LvlTypeMap<VkBindVideoSessionMemoryInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR> {
+    typedef VkBindVideoSessionMemoryInfoKHR Type;
+};
+
+// Map type VkVideoSessionCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoSessionCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR> {
+    typedef VkVideoSessionCreateInfoKHR Type;
+};
+
+// Map type VkVideoSessionParametersCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoSessionParametersCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR> {
+    typedef VkVideoSessionParametersCreateInfoKHR Type;
+};
+
+// Map type VkVideoSessionParametersUpdateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoSessionParametersUpdateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR> {
+    typedef VkVideoSessionParametersUpdateInfoKHR Type;
+};
+
+// Map type VkVideoBeginCodingInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoBeginCodingInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR> {
+    typedef VkVideoBeginCodingInfoKHR Type;
+};
+
+// Map type VkVideoEndCodingInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEndCodingInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR> {
+    typedef VkVideoEndCodingInfoKHR Type;
+};
+
+// Map type VkVideoCodingControlInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoCodingControlInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR> {
+    typedef VkVideoCodingControlInfoKHR Type;
+};
+
+// Map type VkVideoDecodeCapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeCapabilitiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR> {
+    typedef VkVideoDecodeCapabilitiesKHR Type;
+};
+
+// Map type VkVideoDecodeUsageInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeUsageInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR> {
+    typedef VkVideoDecodeUsageInfoKHR Type;
+};
+
+// Map type VkVideoDecodeInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR> {
+    typedef VkVideoDecodeInfoKHR Type;
+};
+
+// Map type VkVideoEncodeH264CapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH264CapabilitiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR> {
+    typedef VkVideoEncodeH264CapabilitiesKHR Type;
+};
+
+// Map type VkVideoEncodeH264QualityLevelPropertiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH264QualityLevelPropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR> {
+    typedef VkVideoEncodeH264QualityLevelPropertiesKHR Type;
+};
+
+// Map type VkVideoEncodeH264SessionCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH264SessionCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR> {
+    typedef VkVideoEncodeH264SessionCreateInfoKHR Type;
+};
+
+// Map type VkVideoEncodeH264SessionParametersAddInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH264SessionParametersAddInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR> {
+    typedef VkVideoEncodeH264SessionParametersAddInfoKHR Type;
+};
+
+// Map type VkVideoEncodeH264SessionParametersCreateInfoKHR to id
+// VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH264SessionParametersCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR> {
+    typedef VkVideoEncodeH264SessionParametersCreateInfoKHR Type;
+};
+
+// Map type VkVideoEncodeH264SessionParametersGetInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH264SessionParametersGetInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR> {
+    typedef VkVideoEncodeH264SessionParametersGetInfoKHR Type;
+};
+
+// Map type VkVideoEncodeH264SessionParametersFeedbackInfoKHR to id
+// VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH264SessionParametersFeedbackInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR> {
+    typedef VkVideoEncodeH264SessionParametersFeedbackInfoKHR Type;
+};
+
+// Map type VkVideoEncodeH264NaluSliceInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH264NaluSliceInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR> {
+    typedef VkVideoEncodeH264NaluSliceInfoKHR Type;
+};
+
+// Map type VkVideoEncodeH264PictureInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH264PictureInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR> {
+    typedef VkVideoEncodeH264PictureInfoKHR Type;
+};
+
+// Map type VkVideoEncodeH264DpbSlotInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH264DpbSlotInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR> {
+    typedef VkVideoEncodeH264DpbSlotInfoKHR Type;
+};
+
+// Map type VkVideoEncodeH264ProfileInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH264ProfileInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR> {
+    typedef VkVideoEncodeH264ProfileInfoKHR Type;
+};
+
+// Map type VkVideoEncodeH264RateControlInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH264RateControlInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR> {
+    typedef VkVideoEncodeH264RateControlInfoKHR Type;
+};
+
+// Map type VkVideoEncodeH264RateControlLayerInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH264RateControlLayerInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR> {
+    typedef VkVideoEncodeH264RateControlLayerInfoKHR Type;
+};
+
+// Map type VkVideoEncodeH264GopRemainingFrameInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH264GopRemainingFrameInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR> {
+    typedef VkVideoEncodeH264GopRemainingFrameInfoKHR Type;
+};
+
+// Map type VkVideoEncodeH265CapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH265CapabilitiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR> {
+    typedef VkVideoEncodeH265CapabilitiesKHR Type;
+};
+
+// Map type VkVideoEncodeH265SessionCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH265SessionCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR> {
+    typedef VkVideoEncodeH265SessionCreateInfoKHR Type;
+};
+
+// Map type VkVideoEncodeH265QualityLevelPropertiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH265QualityLevelPropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR> {
+    typedef VkVideoEncodeH265QualityLevelPropertiesKHR Type;
+};
+
+// Map type VkVideoEncodeH265SessionParametersAddInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH265SessionParametersAddInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR> {
+    typedef VkVideoEncodeH265SessionParametersAddInfoKHR Type;
+};
+
+// Map type VkVideoEncodeH265SessionParametersCreateInfoKHR to id
+// VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH265SessionParametersCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR> {
+    typedef VkVideoEncodeH265SessionParametersCreateInfoKHR Type;
+};
+
+// Map type VkVideoEncodeH265SessionParametersGetInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH265SessionParametersGetInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR> {
+    typedef VkVideoEncodeH265SessionParametersGetInfoKHR Type;
+};
+
+// Map type VkVideoEncodeH265SessionParametersFeedbackInfoKHR to id
+// VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH265SessionParametersFeedbackInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR> {
+    typedef VkVideoEncodeH265SessionParametersFeedbackInfoKHR Type;
+};
+
+// Map type VkVideoEncodeH265NaluSliceSegmentInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH265NaluSliceSegmentInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR> {
+    typedef VkVideoEncodeH265NaluSliceSegmentInfoKHR Type;
+};
+
+// Map type VkVideoEncodeH265PictureInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH265PictureInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR> {
+    typedef VkVideoEncodeH265PictureInfoKHR Type;
+};
+
+// Map type VkVideoEncodeH265DpbSlotInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH265DpbSlotInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR> {
+    typedef VkVideoEncodeH265DpbSlotInfoKHR Type;
+};
+
+// Map type VkVideoEncodeH265ProfileInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH265ProfileInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR> {
+    typedef VkVideoEncodeH265ProfileInfoKHR Type;
+};
+
+// Map type VkVideoEncodeH265RateControlInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH265RateControlInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR> {
+    typedef VkVideoEncodeH265RateControlInfoKHR Type;
+};
+
+// Map type VkVideoEncodeH265RateControlLayerInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH265RateControlLayerInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR> {
+    typedef VkVideoEncodeH265RateControlLayerInfoKHR Type;
+};
+
+// Map type VkVideoEncodeH265GopRemainingFrameInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH265GopRemainingFrameInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR> {
+    typedef VkVideoEncodeH265GopRemainingFrameInfoKHR Type;
+};
+
+// Map type VkVideoDecodeH264ProfileInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeH264ProfileInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR> {
+    typedef VkVideoDecodeH264ProfileInfoKHR Type;
+};
+
+// Map type VkVideoDecodeH264CapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeH264CapabilitiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR> {
+    typedef VkVideoDecodeH264CapabilitiesKHR Type;
+};
+
+// Map type VkVideoDecodeH264SessionParametersAddInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeH264SessionParametersAddInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR> {
+    typedef VkVideoDecodeH264SessionParametersAddInfoKHR Type;
+};
+
+// Map type VkVideoDecodeH264SessionParametersCreateInfoKHR to id
+// VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeH264SessionParametersCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR> {
+    typedef VkVideoDecodeH264SessionParametersCreateInfoKHR Type;
+};
+
+// Map type VkVideoDecodeH264PictureInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeH264PictureInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR> {
+    typedef VkVideoDecodeH264PictureInfoKHR Type;
+};
+
+// Map type VkVideoDecodeH264DpbSlotInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeH264DpbSlotInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR> {
+    typedef VkVideoDecodeH264DpbSlotInfoKHR Type;
+};
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+// Map type VkImportMemoryWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR
+template <>
+struct LvlTypeMap<VkImportMemoryWin32HandleInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR> {
+    typedef VkImportMemoryWin32HandleInfoKHR Type;
+};
+
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+// Map type VkExportMemoryWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR
+template <>
+struct LvlTypeMap<VkExportMemoryWin32HandleInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR> {
+    typedef VkExportMemoryWin32HandleInfoKHR Type;
+};
+
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+// Map type VkMemoryWin32HandlePropertiesKHR to id VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkMemoryWin32HandlePropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR> {
+    typedef VkMemoryWin32HandlePropertiesKHR Type;
+};
+
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+// Map type VkMemoryGetWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR
+template <>
+struct LvlTypeMap<VkMemoryGetWin32HandleInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR> {
+    typedef VkMemoryGetWin32HandleInfoKHR Type;
+};
+
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+// Map type VkImportMemoryFdInfoKHR to id VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR
+template <>
+struct LvlTypeMap<VkImportMemoryFdInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR> {
+    typedef VkImportMemoryFdInfoKHR Type;
+};
+
+// Map type VkMemoryFdPropertiesKHR to id VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkMemoryFdPropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR> {
+    typedef VkMemoryFdPropertiesKHR Type;
+};
+
+// Map type VkMemoryGetFdInfoKHR to id VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR
+template <>
+struct LvlTypeMap<VkMemoryGetFdInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR> {
+    typedef VkMemoryGetFdInfoKHR Type;
+};
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+// Map type VkWin32KeyedMutexAcquireReleaseInfoKHR to id VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR
+template <>
+struct LvlTypeMap<VkWin32KeyedMutexAcquireReleaseInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR> {
+    typedef VkWin32KeyedMutexAcquireReleaseInfoKHR Type;
+};
+
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+// Map type VkImportSemaphoreWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR
+template <>
+struct LvlTypeMap<VkImportSemaphoreWin32HandleInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR> {
+    typedef VkImportSemaphoreWin32HandleInfoKHR Type;
+};
+
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+// Map type VkExportSemaphoreWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR
+template <>
+struct LvlTypeMap<VkExportSemaphoreWin32HandleInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR> {
+    typedef VkExportSemaphoreWin32HandleInfoKHR Type;
+};
+
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+// Map type VkD3D12FenceSubmitInfoKHR to id VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR
+template <>
+struct LvlTypeMap<VkD3D12FenceSubmitInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR> {
+    typedef VkD3D12FenceSubmitInfoKHR Type;
+};
+
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+// Map type VkSemaphoreGetWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR
+template <>
+struct LvlTypeMap<VkSemaphoreGetWin32HandleInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR> {
+    typedef VkSemaphoreGetWin32HandleInfoKHR Type;
+};
+
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+// Map type VkImportSemaphoreFdInfoKHR to id VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR
+template <>
+struct LvlTypeMap<VkImportSemaphoreFdInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR> {
+    typedef VkImportSemaphoreFdInfoKHR Type;
+};
+
+// Map type VkSemaphoreGetFdInfoKHR to id VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR
+template <>
+struct LvlTypeMap<VkSemaphoreGetFdInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR> {
+    typedef VkSemaphoreGetFdInfoKHR Type;
+};
+
+// Map type VkPresentRegionsKHR to id VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR
+template <>
+struct LvlTypeMap<VkPresentRegionsKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR> {
+    typedef VkPresentRegionsKHR Type;
+};
+
+// Map type VkSharedPresentSurfaceCapabilitiesKHR to id VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR
+template <>
+struct LvlTypeMap<VkSharedPresentSurfaceCapabilitiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR> {
+    typedef VkSharedPresentSurfaceCapabilitiesKHR Type;
+};
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+// Map type VkImportFenceWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR
+template <>
+struct LvlTypeMap<VkImportFenceWin32HandleInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR> {
+    typedef VkImportFenceWin32HandleInfoKHR Type;
+};
+
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+// Map type VkExportFenceWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR
+template <>
+struct LvlTypeMap<VkExportFenceWin32HandleInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR> {
+    typedef VkExportFenceWin32HandleInfoKHR Type;
+};
+
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+// Map type VkFenceGetWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR
+template <>
+struct LvlTypeMap<VkFenceGetWin32HandleInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR> {
+    typedef VkFenceGetWin32HandleInfoKHR Type;
+};
+
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+// Map type VkImportFenceFdInfoKHR to id VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR
+template <>
+struct LvlTypeMap<VkImportFenceFdInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR> {
+    typedef VkImportFenceFdInfoKHR Type;
+};
+
+// Map type VkFenceGetFdInfoKHR to id VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR
+template <>
+struct LvlTypeMap<VkFenceGetFdInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR> {
+    typedef VkFenceGetFdInfoKHR Type;
+};
+
+// Map type VkPhysicalDevicePerformanceQueryFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDevicePerformanceQueryFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR> {
+    typedef VkPhysicalDevicePerformanceQueryFeaturesKHR Type;
+};
+
+// Map type VkPhysicalDevicePerformanceQueryPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDevicePerformanceQueryPropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR> {
+    typedef VkPhysicalDevicePerformanceQueryPropertiesKHR Type;
+};
+
+// Map type VkPerformanceCounterKHR to id VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR
+template <>
+struct LvlTypeMap<VkPerformanceCounterKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR> {
+    typedef VkPerformanceCounterKHR Type;
+};
+
+// Map type VkPerformanceCounterDescriptionKHR to id VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR
+template <>
+struct LvlTypeMap<VkPerformanceCounterDescriptionKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR> {
+    typedef VkPerformanceCounterDescriptionKHR Type;
+};
+
+// Map type VkQueryPoolPerformanceCreateInfoKHR to id VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkQueryPoolPerformanceCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR> {
+    typedef VkQueryPoolPerformanceCreateInfoKHR Type;
+};
+
+// Map type VkAcquireProfilingLockInfoKHR to id VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR
+template <>
+struct LvlTypeMap<VkAcquireProfilingLockInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR> {
+    typedef VkAcquireProfilingLockInfoKHR Type;
+};
+
+// Map type VkPerformanceQuerySubmitInfoKHR to id VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR
+template <>
+struct LvlTypeMap<VkPerformanceQuerySubmitInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR> {
+    typedef VkPerformanceQuerySubmitInfoKHR Type;
+};
+
+// Map type VkPhysicalDeviceSurfaceInfo2KHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceSurfaceInfo2KHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR> {
+    typedef VkPhysicalDeviceSurfaceInfo2KHR Type;
+};
+
+// Map type VkSurfaceCapabilities2KHR to id VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR
+template <>
+struct LvlTypeMap<VkSurfaceCapabilities2KHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR> {
+    typedef VkSurfaceCapabilities2KHR Type;
+};
+
+// Map type VkSurfaceFormat2KHR to id VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR
+template <>
+struct LvlTypeMap<VkSurfaceFormat2KHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR> {
+    typedef VkSurfaceFormat2KHR Type;
+};
+
+// Map type VkDisplayProperties2KHR to id VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR
+template <>
+struct LvlTypeMap<VkDisplayProperties2KHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR> {
+    typedef VkDisplayProperties2KHR Type;
+};
+
+// Map type VkDisplayPlaneProperties2KHR to id VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR
+template <>
+struct LvlTypeMap<VkDisplayPlaneProperties2KHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR> {
+    typedef VkDisplayPlaneProperties2KHR Type;
+};
+
+// Map type VkDisplayModeProperties2KHR to id VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR
+template <>
+struct LvlTypeMap<VkDisplayModeProperties2KHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR> {
+    typedef VkDisplayModeProperties2KHR Type;
+};
+
+// Map type VkDisplayPlaneInfo2KHR to id VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR
+template <>
+struct LvlTypeMap<VkDisplayPlaneInfo2KHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR> {
+    typedef VkDisplayPlaneInfo2KHR Type;
+};
+
+// Map type VkDisplayPlaneCapabilities2KHR to id VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR
+template <>
+struct LvlTypeMap<VkDisplayPlaneCapabilities2KHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR> {
+    typedef VkDisplayPlaneCapabilities2KHR Type;
+};
+
+// Map type VkPhysicalDeviceShaderBfloat16FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderBfloat16FeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR> {
+    typedef VkPhysicalDeviceShaderBfloat16FeaturesKHR Type;
+};
+
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+// Map type VkPhysicalDevicePortabilitySubsetFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDevicePortabilitySubsetFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR> {
+    typedef VkPhysicalDevicePortabilitySubsetFeaturesKHR Type;
+};
+
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+// Map type VkPhysicalDevicePortabilitySubsetPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDevicePortabilitySubsetPropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR> {
+    typedef VkPhysicalDevicePortabilitySubsetPropertiesKHR Type;
+};
+
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+// Map type VkPhysicalDeviceShaderClockFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderClockFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR> {
+    typedef VkPhysicalDeviceShaderClockFeaturesKHR Type;
+};
+
+// Map type VkVideoDecodeH265ProfileInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeH265ProfileInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR> {
+    typedef VkVideoDecodeH265ProfileInfoKHR Type;
+};
+
+// Map type VkVideoDecodeH265CapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeH265CapabilitiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR> {
+    typedef VkVideoDecodeH265CapabilitiesKHR Type;
+};
+
+// Map type VkVideoDecodeH265SessionParametersAddInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeH265SessionParametersAddInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR> {
+    typedef VkVideoDecodeH265SessionParametersAddInfoKHR Type;
+};
+
+// Map type VkVideoDecodeH265SessionParametersCreateInfoKHR to id
+// VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeH265SessionParametersCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR> {
+    typedef VkVideoDecodeH265SessionParametersCreateInfoKHR Type;
+};
+
+// Map type VkVideoDecodeH265PictureInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeH265PictureInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR> {
+    typedef VkVideoDecodeH265PictureInfoKHR Type;
+};
+
+// Map type VkVideoDecodeH265DpbSlotInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeH265DpbSlotInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR> {
+    typedef VkVideoDecodeH265DpbSlotInfoKHR Type;
+};
+
+// Map type VkFragmentShadingRateAttachmentInfoKHR to id VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR
+template <>
+struct LvlTypeMap<VkFragmentShadingRateAttachmentInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR> {
+    typedef VkFragmentShadingRateAttachmentInfoKHR Type;
+};
+
+// Map type VkPipelineFragmentShadingRateStateCreateInfoKHR to id
+// VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkPipelineFragmentShadingRateStateCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR> {
+    typedef VkPipelineFragmentShadingRateStateCreateInfoKHR Type;
+};
+
+// Map type VkPhysicalDeviceFragmentShadingRateFeaturesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceFragmentShadingRateFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR> {
+    typedef VkPhysicalDeviceFragmentShadingRateFeaturesKHR Type;
+};
+
+// Map type VkPhysicalDeviceFragmentShadingRatePropertiesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceFragmentShadingRatePropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR> {
+    typedef VkPhysicalDeviceFragmentShadingRatePropertiesKHR Type;
+};
+
+// Map type VkPhysicalDeviceFragmentShadingRateKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceFragmentShadingRateKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR> {
+    typedef VkPhysicalDeviceFragmentShadingRateKHR Type;
+};
+
+// Map type VkRenderingFragmentShadingRateAttachmentInfoKHR to id
+// VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR
+template <>
+struct LvlTypeMap<VkRenderingFragmentShadingRateAttachmentInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR> {
+    typedef VkRenderingFragmentShadingRateAttachmentInfoKHR Type;
+};
+
+// Map type VkPhysicalDeviceShaderConstantDataFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderConstantDataFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR> {
+    typedef VkPhysicalDeviceShaderConstantDataFeaturesKHR Type;
+};
+
+// Map type VkPhysicalDeviceShaderAbortFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderAbortFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR> {
+    typedef VkPhysicalDeviceShaderAbortFeaturesKHR Type;
+};
+
+// Map type VkDeviceFaultShaderAbortMessageInfoKHR to id VK_STRUCTURE_TYPE_DEVICE_FAULT_SHADER_ABORT_MESSAGE_INFO_KHR
+template <>
+struct LvlTypeMap<VkDeviceFaultShaderAbortMessageInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_FAULT_SHADER_ABORT_MESSAGE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_FAULT_SHADER_ABORT_MESSAGE_INFO_KHR> {
+    typedef VkDeviceFaultShaderAbortMessageInfoKHR Type;
+};
+
+// Map type VkPhysicalDeviceShaderAbortPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderAbortPropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES_KHR> {
+    typedef VkPhysicalDeviceShaderAbortPropertiesKHR Type;
+};
+
+// Map type VkPhysicalDeviceShaderQuadControlFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderQuadControlFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR> {
+    typedef VkPhysicalDeviceShaderQuadControlFeaturesKHR Type;
+};
+
+// Map type VkSurfaceProtectedCapabilitiesKHR to id VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR
+template <>
+struct LvlTypeMap<VkSurfaceProtectedCapabilitiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR> {
+    typedef VkSurfaceProtectedCapabilitiesKHR Type;
+};
+
+// Map type VkPhysicalDevicePresentWaitFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDevicePresentWaitFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR> {
+    typedef VkPhysicalDevicePresentWaitFeaturesKHR Type;
+};
+
+// Map type VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR> {
+    typedef VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR Type;
+};
+
+// Map type VkPipelineInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR
+template <>
+struct LvlTypeMap<VkPipelineInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR> {
+    typedef VkPipelineInfoKHR Type;
+};
+
+// Map type VkPipelineExecutablePropertiesKHR to id VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkPipelineExecutablePropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR> {
+    typedef VkPipelineExecutablePropertiesKHR Type;
+};
+
+// Map type VkPipelineExecutableInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR
+template <>
+struct LvlTypeMap<VkPipelineExecutableInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR> {
+    typedef VkPipelineExecutableInfoKHR Type;
+};
+
+// Map type VkPipelineExecutableStatisticKHR to id VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR
+template <>
+struct LvlTypeMap<VkPipelineExecutableStatisticKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR> {
+    typedef VkPipelineExecutableStatisticKHR Type;
+};
+
+// Map type VkPipelineExecutableInternalRepresentationKHR to id VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR
+template <>
+struct LvlTypeMap<VkPipelineExecutableInternalRepresentationKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR> {
+    typedef VkPipelineExecutableInternalRepresentationKHR Type;
+};
+
+// Map type VkPipelineLibraryCreateInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkPipelineLibraryCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR> {
+    typedef VkPipelineLibraryCreateInfoKHR Type;
+};
+
+// Map type VkPresentIdKHR to id VK_STRUCTURE_TYPE_PRESENT_ID_KHR
+template <>
+struct LvlTypeMap<VkPresentIdKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_ID_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_ID_KHR> {
+    typedef VkPresentIdKHR Type;
+};
+
+// Map type VkPhysicalDevicePresentIdFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDevicePresentIdFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR> {
+    typedef VkPhysicalDevicePresentIdFeaturesKHR Type;
+};
+
+// Map type VkVideoEncodeInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR> {
+    typedef VkVideoEncodeInfoKHR Type;
+};
+
+// Map type VkVideoEncodeCapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeCapabilitiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR> {
+    typedef VkVideoEncodeCapabilitiesKHR Type;
+};
+
+// Map type VkQueryPoolVideoEncodeFeedbackCreateInfoKHR to id VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkQueryPoolVideoEncodeFeedbackCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR> {
+    typedef VkQueryPoolVideoEncodeFeedbackCreateInfoKHR Type;
+};
+
+// Map type VkVideoEncodeUsageInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeUsageInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR> {
+    typedef VkVideoEncodeUsageInfoKHR Type;
+};
+
+// Map type VkVideoEncodeRateControlLayerInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeRateControlLayerInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR> {
+    typedef VkVideoEncodeRateControlLayerInfoKHR Type;
+};
+
+// Map type VkVideoEncodeRateControlInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeRateControlInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR> {
+    typedef VkVideoEncodeRateControlInfoKHR Type;
+};
+
+// Map type VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR> {
+    typedef VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR Type;
+};
+
+// Map type VkVideoEncodeQualityLevelPropertiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeQualityLevelPropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR> {
+    typedef VkVideoEncodeQualityLevelPropertiesKHR Type;
+};
+
+// Map type VkVideoEncodeQualityLevelInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeQualityLevelInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR> {
+    typedef VkVideoEncodeQualityLevelInfoKHR Type;
+};
+
+// Map type VkVideoEncodeSessionParametersGetInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeSessionParametersGetInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR> {
+    typedef VkVideoEncodeSessionParametersGetInfoKHR Type;
+};
+
+// Map type VkVideoEncodeSessionParametersFeedbackInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeSessionParametersFeedbackInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR> {
+    typedef VkVideoEncodeSessionParametersFeedbackInfoKHR Type;
+};
+
+// Map type VkDeviceMemoryCopyKHR to id VK_STRUCTURE_TYPE_DEVICE_MEMORY_COPY_KHR
+template <>
+struct LvlTypeMap<VkDeviceMemoryCopyKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_COPY_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_MEMORY_COPY_KHR> {
+    typedef VkDeviceMemoryCopyKHR Type;
+};
+
+// Map type VkCopyDeviceMemoryInfoKHR to id VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_INFO_KHR
+template <>
+struct LvlTypeMap<VkCopyDeviceMemoryInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_INFO_KHR> {
+    typedef VkCopyDeviceMemoryInfoKHR Type;
+};
+
+// Map type VkDeviceMemoryImageCopyKHR to id VK_STRUCTURE_TYPE_DEVICE_MEMORY_IMAGE_COPY_KHR
+template <>
+struct LvlTypeMap<VkDeviceMemoryImageCopyKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_IMAGE_COPY_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_MEMORY_IMAGE_COPY_KHR> {
+    typedef VkDeviceMemoryImageCopyKHR Type;
+};
+
+// Map type VkCopyDeviceMemoryImageInfoKHR to id VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_IMAGE_INFO_KHR
+template <>
+struct LvlTypeMap<VkCopyDeviceMemoryImageInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_IMAGE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_IMAGE_INFO_KHR> {
+    typedef VkCopyDeviceMemoryImageInfoKHR Type;
+};
+
+// Map type VkMemoryRangeBarrierKHR to id VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIER_KHR
+template <>
+struct LvlTypeMap<VkMemoryRangeBarrierKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIER_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIER_KHR> {
+    typedef VkMemoryRangeBarrierKHR Type;
+};
+
+// Map type VkMemoryRangeBarriersInfoKHR to id VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIERS_INFO_KHR
+template <>
+struct LvlTypeMap<VkMemoryRangeBarriersInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIERS_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_RANGE_BARRIERS_INFO_KHR> {
+    typedef VkMemoryRangeBarriersInfoKHR Type;
+};
+
+// Map type VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR> {
+    typedef VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR Type;
+};
+
+// Map type VkBindIndexBuffer3InfoKHR to id VK_STRUCTURE_TYPE_BIND_INDEX_BUFFER_3_INFO_KHR
+template <>
+struct LvlTypeMap<VkBindIndexBuffer3InfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_INDEX_BUFFER_3_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_INDEX_BUFFER_3_INFO_KHR> {
+    typedef VkBindIndexBuffer3InfoKHR Type;
+};
+
+// Map type VkBindVertexBuffer3InfoKHR to id VK_STRUCTURE_TYPE_BIND_VERTEX_BUFFER_3_INFO_KHR
+template <>
+struct LvlTypeMap<VkBindVertexBuffer3InfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_VERTEX_BUFFER_3_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_VERTEX_BUFFER_3_INFO_KHR> {
+    typedef VkBindVertexBuffer3InfoKHR Type;
+};
+
+// Map type VkDrawIndirect2InfoKHR to id VK_STRUCTURE_TYPE_DRAW_INDIRECT_2_INFO_KHR
+template <>
+struct LvlTypeMap<VkDrawIndirect2InfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DRAW_INDIRECT_2_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DRAW_INDIRECT_2_INFO_KHR> {
+    typedef VkDrawIndirect2InfoKHR Type;
+};
+
+// Map type VkDrawIndirectCount2InfoKHR to id VK_STRUCTURE_TYPE_DRAW_INDIRECT_COUNT_2_INFO_KHR
+template <>
+struct LvlTypeMap<VkDrawIndirectCount2InfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DRAW_INDIRECT_COUNT_2_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DRAW_INDIRECT_COUNT_2_INFO_KHR> {
+    typedef VkDrawIndirectCount2InfoKHR Type;
+};
+
+// Map type VkDispatchIndirect2InfoKHR to id VK_STRUCTURE_TYPE_DISPATCH_INDIRECT_2_INFO_KHR
+template <>
+struct LvlTypeMap<VkDispatchIndirect2InfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPATCH_INDIRECT_2_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPATCH_INDIRECT_2_INFO_KHR> {
+    typedef VkDispatchIndirect2InfoKHR Type;
+};
+
+// Map type VkConditionalRenderingBeginInfo2EXT to id VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_2_EXT
+template <>
+struct LvlTypeMap<VkConditionalRenderingBeginInfo2EXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_2_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_2_EXT> {
+    typedef VkConditionalRenderingBeginInfo2EXT Type;
+};
+
+// Map type VkBindTransformFeedbackBuffer2InfoEXT to id VK_STRUCTURE_TYPE_BIND_TRANSFORM_FEEDBACK_BUFFER_2_INFO_EXT
+template <>
+struct LvlTypeMap<VkBindTransformFeedbackBuffer2InfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_TRANSFORM_FEEDBACK_BUFFER_2_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_TRANSFORM_FEEDBACK_BUFFER_2_INFO_EXT> {
+    typedef VkBindTransformFeedbackBuffer2InfoEXT Type;
+};
+
+// Map type VkMemoryMarkerInfoAMD to id VK_STRUCTURE_TYPE_MEMORY_MARKER_INFO_AMD
+template <>
+struct LvlTypeMap<VkMemoryMarkerInfoAMD> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_MARKER_INFO_AMD;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_MARKER_INFO_AMD> {
+    typedef VkMemoryMarkerInfoAMD Type;
+};
+
+// Map type VkAccelerationStructureCreateInfo2KHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_2_KHR
+template <>
+struct LvlTypeMap<VkAccelerationStructureCreateInfo2KHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_2_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_2_KHR> {
+    typedef VkAccelerationStructureCreateInfo2KHR Type;
+};
+
+// Map type VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR> {
+    typedef VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR Type;
+};
+
+// Map type VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR> {
+    typedef VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR Type;
+};
+
+// Map type VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR> {
+    typedef VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR Type;
+};
+
+// Map type VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR> {
+    typedef VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR Type;
+};
+
+// Map type VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR> {
+    typedef VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR Type;
+};
+
+// Map type VkPhysicalDeviceShaderUntypedPointersFeaturesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderUntypedPointersFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR> {
+    typedef VkPhysicalDeviceShaderUntypedPointersFeaturesKHR Type;
+};
+
+// Map type VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR> {
+    typedef VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR Type;
+};
+
+// Map type VkSurfaceCapabilitiesPresentId2KHR to id VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR
+template <>
+struct LvlTypeMap<VkSurfaceCapabilitiesPresentId2KHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR> {
+    typedef VkSurfaceCapabilitiesPresentId2KHR Type;
+};
+
+// Map type VkPresentId2KHR to id VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR
+template <>
+struct LvlTypeMap<VkPresentId2KHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR> {
+    typedef VkPresentId2KHR Type;
+};
+
+// Map type VkPhysicalDevicePresentId2FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDevicePresentId2FeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR> {
+    typedef VkPhysicalDevicePresentId2FeaturesKHR Type;
+};
+
+// Map type VkSurfaceCapabilitiesPresentWait2KHR to id VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR
+template <>
+struct LvlTypeMap<VkSurfaceCapabilitiesPresentWait2KHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR> {
+    typedef VkSurfaceCapabilitiesPresentWait2KHR Type;
+};
+
+// Map type VkPhysicalDevicePresentWait2FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDevicePresentWait2FeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR> {
+    typedef VkPhysicalDevicePresentWait2FeaturesKHR Type;
+};
+
+// Map type VkPresentWait2InfoKHR to id VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR
+template <>
+struct LvlTypeMap<VkPresentWait2InfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR> {
+    typedef VkPresentWait2InfoKHR Type;
+};
+
+// Map type VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR> {
+    typedef VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR Type;
+};
+
+// Map type VkPhysicalDevicePipelineBinaryFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDevicePipelineBinaryFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR> {
+    typedef VkPhysicalDevicePipelineBinaryFeaturesKHR Type;
+};
+
+// Map type VkPhysicalDevicePipelineBinaryPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDevicePipelineBinaryPropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR> {
+    typedef VkPhysicalDevicePipelineBinaryPropertiesKHR Type;
+};
+
+// Map type VkDevicePipelineBinaryInternalCacheControlKHR to id VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR
+template <>
+struct LvlTypeMap<VkDevicePipelineBinaryInternalCacheControlKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR> {
+    typedef VkDevicePipelineBinaryInternalCacheControlKHR Type;
+};
+
+// Map type VkPipelineBinaryKeyKHR to id VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR
+template <>
+struct LvlTypeMap<VkPipelineBinaryKeyKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR> {
+    typedef VkPipelineBinaryKeyKHR Type;
+};
+
+// Map type VkPipelineCreateInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkPipelineCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR> {
+    typedef VkPipelineCreateInfoKHR Type;
+};
+
+// Map type VkPipelineBinaryCreateInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkPipelineBinaryCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR> {
+    typedef VkPipelineBinaryCreateInfoKHR Type;
+};
+
+// Map type VkPipelineBinaryInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR
+template <>
+struct LvlTypeMap<VkPipelineBinaryInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR> {
+    typedef VkPipelineBinaryInfoKHR Type;
+};
+
+// Map type VkReleaseCapturedPipelineDataInfoKHR to id VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR
+template <>
+struct LvlTypeMap<VkReleaseCapturedPipelineDataInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR> {
+    typedef VkReleaseCapturedPipelineDataInfoKHR Type;
+};
+
+// Map type VkPipelineBinaryDataInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR
+template <>
+struct LvlTypeMap<VkPipelineBinaryDataInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR> {
+    typedef VkPipelineBinaryDataInfoKHR Type;
+};
+
+// Map type VkPipelineBinaryHandlesInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR
+template <>
+struct LvlTypeMap<VkPipelineBinaryHandlesInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR> {
+    typedef VkPipelineBinaryHandlesInfoKHR Type;
+};
+
+// Map type VkSurfacePresentModeKHR to id VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR
+template <>
+struct LvlTypeMap<VkSurfacePresentModeKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR> {
+    typedef VkSurfacePresentModeKHR Type;
+};
+
+// Map type VkSurfacePresentScalingCapabilitiesKHR to id VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR
+template <>
+struct LvlTypeMap<VkSurfacePresentScalingCapabilitiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR> {
+    typedef VkSurfacePresentScalingCapabilitiesKHR Type;
+};
+
+// Map type VkSurfacePresentModeCompatibilityKHR to id VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR
+template <>
+struct LvlTypeMap<VkSurfacePresentModeCompatibilityKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR> {
+    typedef VkSurfacePresentModeCompatibilityKHR Type;
+};
+
+// Map type VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR> {
+    typedef VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR Type;
+};
+
+// Map type VkSwapchainPresentFenceInfoKHR to id VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR
+template <>
+struct LvlTypeMap<VkSwapchainPresentFenceInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR> {
+    typedef VkSwapchainPresentFenceInfoKHR Type;
+};
+
+// Map type VkSwapchainPresentModesCreateInfoKHR to id VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkSwapchainPresentModesCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR> {
+    typedef VkSwapchainPresentModesCreateInfoKHR Type;
+};
+
+// Map type VkSwapchainPresentModeInfoKHR to id VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR
+template <>
+struct LvlTypeMap<VkSwapchainPresentModeInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR> {
+    typedef VkSwapchainPresentModeInfoKHR Type;
+};
+
+// Map type VkSwapchainPresentScalingCreateInfoKHR to id VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkSwapchainPresentScalingCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR> {
+    typedef VkSwapchainPresentScalingCreateInfoKHR Type;
+};
+
+// Map type VkReleaseSwapchainImagesInfoKHR to id VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR
+template <>
+struct LvlTypeMap<VkReleaseSwapchainImagesInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR> {
+    typedef VkReleaseSwapchainImagesInfoKHR Type;
+};
+
+// Map type VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR> {
+    typedef VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR Type;
+};
+
+// Map type VkCooperativeMatrixPropertiesKHR to id VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkCooperativeMatrixPropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR> {
+    typedef VkCooperativeMatrixPropertiesKHR Type;
+};
+
+// Map type VkPhysicalDeviceCooperativeMatrixFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceCooperativeMatrixFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR> {
+    typedef VkPhysicalDeviceCooperativeMatrixFeaturesKHR Type;
+};
+
+// Map type VkPhysicalDeviceCooperativeMatrixPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceCooperativeMatrixPropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR> {
+    typedef VkPhysicalDeviceCooperativeMatrixPropertiesKHR Type;
+};
+
+// Map type VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR> {
+    typedef VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR Type;
+};
+
+// Map type VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR> {
+    typedef VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR Type;
+};
+
+// Map type VkVideoDecodeAV1ProfileInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeAV1ProfileInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR> {
+    typedef VkVideoDecodeAV1ProfileInfoKHR Type;
+};
+
+// Map type VkVideoDecodeAV1CapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeAV1CapabilitiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR> {
+    typedef VkVideoDecodeAV1CapabilitiesKHR Type;
+};
+
+// Map type VkVideoDecodeAV1SessionParametersCreateInfoKHR to id
+// VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeAV1SessionParametersCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR> {
+    typedef VkVideoDecodeAV1SessionParametersCreateInfoKHR Type;
+};
+
+// Map type VkVideoDecodeAV1PictureInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeAV1PictureInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR> {
+    typedef VkVideoDecodeAV1PictureInfoKHR Type;
+};
+
+// Map type VkVideoDecodeAV1DpbSlotInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeAV1DpbSlotInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR> {
+    typedef VkVideoDecodeAV1DpbSlotInfoKHR Type;
+};
+
+// Map type VkPhysicalDeviceVideoEncodeAV1FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceVideoEncodeAV1FeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR> {
+    typedef VkPhysicalDeviceVideoEncodeAV1FeaturesKHR Type;
+};
+
+// Map type VkVideoEncodeAV1CapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeAV1CapabilitiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR> {
+    typedef VkVideoEncodeAV1CapabilitiesKHR Type;
+};
+
+// Map type VkVideoEncodeAV1QualityLevelPropertiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeAV1QualityLevelPropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR> {
+    typedef VkVideoEncodeAV1QualityLevelPropertiesKHR Type;
+};
+
+// Map type VkVideoEncodeAV1SessionCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeAV1SessionCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR> {
+    typedef VkVideoEncodeAV1SessionCreateInfoKHR Type;
+};
+
+// Map type VkVideoEncodeAV1SessionParametersCreateInfoKHR to id
+// VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeAV1SessionParametersCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR> {
+    typedef VkVideoEncodeAV1SessionParametersCreateInfoKHR Type;
+};
+
+// Map type VkVideoEncodeAV1PictureInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeAV1PictureInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR> {
+    typedef VkVideoEncodeAV1PictureInfoKHR Type;
+};
+
+// Map type VkVideoEncodeAV1DpbSlotInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeAV1DpbSlotInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR> {
+    typedef VkVideoEncodeAV1DpbSlotInfoKHR Type;
+};
+
+// Map type VkVideoEncodeAV1ProfileInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeAV1ProfileInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR> {
+    typedef VkVideoEncodeAV1ProfileInfoKHR Type;
+};
+
+// Map type VkVideoEncodeAV1GopRemainingFrameInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeAV1GopRemainingFrameInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR> {
+    typedef VkVideoEncodeAV1GopRemainingFrameInfoKHR Type;
+};
+
+// Map type VkVideoEncodeAV1RateControlInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeAV1RateControlInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR> {
+    typedef VkVideoEncodeAV1RateControlInfoKHR Type;
+};
+
+// Map type VkVideoEncodeAV1RateControlLayerInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeAV1RateControlLayerInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR> {
+    typedef VkVideoEncodeAV1RateControlLayerInfoKHR Type;
+};
+
+// Map type VkPhysicalDeviceVideoDecodeVP9FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceVideoDecodeVP9FeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR> {
+    typedef VkPhysicalDeviceVideoDecodeVP9FeaturesKHR Type;
+};
+
+// Map type VkVideoDecodeVP9ProfileInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeVP9ProfileInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR> {
+    typedef VkVideoDecodeVP9ProfileInfoKHR Type;
+};
+
+// Map type VkVideoDecodeVP9CapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeVP9CapabilitiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR> {
+    typedef VkVideoDecodeVP9CapabilitiesKHR Type;
+};
+
+// Map type VkVideoDecodeVP9PictureInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeVP9PictureInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR> {
+    typedef VkVideoDecodeVP9PictureInfoKHR Type;
+};
+
+// Map type VkPhysicalDeviceVideoMaintenance1FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceVideoMaintenance1FeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR> {
+    typedef VkPhysicalDeviceVideoMaintenance1FeaturesKHR Type;
+};
+
+// Map type VkVideoInlineQueryInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoInlineQueryInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR> {
+    typedef VkVideoInlineQueryInfoKHR Type;
+};
+
+// Map type VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR> {
+    typedef VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR Type;
+};
+
+// Map type VkAttachmentFeedbackLoopInfoEXT to id VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT
+template <>
+struct LvlTypeMap<VkAttachmentFeedbackLoopInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT> {
+    typedef VkAttachmentFeedbackLoopInfoEXT Type;
+};
+
+// Map type VkCalibratedTimestampInfoKHR to id VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR
+template <>
+struct LvlTypeMap<VkCalibratedTimestampInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR> {
+    typedef VkCalibratedTimestampInfoKHR Type;
+};
+
+// Map type VkSetDescriptorBufferOffsetsInfoEXT to id VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT
+template <>
+struct LvlTypeMap<VkSetDescriptorBufferOffsetsInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT> {
+    typedef VkSetDescriptorBufferOffsetsInfoEXT Type;
+};
+
+// Map type VkBindDescriptorBufferEmbeddedSamplersInfoEXT to id VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT
+template <>
+struct LvlTypeMap<VkBindDescriptorBufferEmbeddedSamplersInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT> {
+    typedef VkBindDescriptorBufferEmbeddedSamplersInfoEXT Type;
+};
+
+// Map type VkCopyMemoryIndirectInfoKHR to id VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR
+template <>
+struct LvlTypeMap<VkCopyMemoryIndirectInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR> {
+    typedef VkCopyMemoryIndirectInfoKHR Type;
+};
+
+// Map type VkCopyMemoryToImageIndirectInfoKHR to id VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR
+template <>
+struct LvlTypeMap<VkCopyMemoryToImageIndirectInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR> {
+    typedef VkCopyMemoryToImageIndirectInfoKHR Type;
+};
+
+// Map type VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR> {
+    typedef VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR Type;
+};
+
+// Map type VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR> {
+    typedef VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR Type;
+};
+
+// Map type VkVideoEncodeIntraRefreshCapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeIntraRefreshCapabilitiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR> {
+    typedef VkVideoEncodeIntraRefreshCapabilitiesKHR Type;
+};
+
+// Map type VkVideoEncodeSessionIntraRefreshCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeSessionIntraRefreshCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR> {
+    typedef VkVideoEncodeSessionIntraRefreshCreateInfoKHR Type;
+};
+
+// Map type VkVideoEncodeIntraRefreshInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeIntraRefreshInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR> {
+    typedef VkVideoEncodeIntraRefreshInfoKHR Type;
+};
+
+// Map type VkVideoReferenceIntraRefreshInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoReferenceIntraRefreshInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR> {
+    typedef VkVideoReferenceIntraRefreshInfoKHR Type;
+};
+
+// Map type VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR> {
+    typedef VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR Type;
+};
+
+// Map type VkVideoEncodeQuantizationMapCapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeQuantizationMapCapabilitiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR> {
+    typedef VkVideoEncodeQuantizationMapCapabilitiesKHR Type;
+};
+
+// Map type VkVideoFormatQuantizationMapPropertiesKHR to id VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkVideoFormatQuantizationMapPropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR> {
+    typedef VkVideoFormatQuantizationMapPropertiesKHR Type;
+};
+
+// Map type VkVideoEncodeQuantizationMapInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeQuantizationMapInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR> {
+    typedef VkVideoEncodeQuantizationMapInfoKHR Type;
+};
+
+// Map type VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR to id
+// VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR> {
+    typedef VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR Type;
+};
+
+// Map type VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR> {
+    typedef VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR Type;
+};
+
+// Map type VkVideoEncodeH264QuantizationMapCapabilitiesKHR to id
+// VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH264QuantizationMapCapabilitiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR> {
+    typedef VkVideoEncodeH264QuantizationMapCapabilitiesKHR Type;
+};
+
+// Map type VkVideoEncodeH265QuantizationMapCapabilitiesKHR to id
+// VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeH265QuantizationMapCapabilitiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR> {
+    typedef VkVideoEncodeH265QuantizationMapCapabilitiesKHR Type;
+};
+
+// Map type VkVideoFormatH265QuantizationMapPropertiesKHR to id VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkVideoFormatH265QuantizationMapPropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR> {
+    typedef VkVideoFormatH265QuantizationMapPropertiesKHR Type;
+};
+
+// Map type VkVideoEncodeAV1QuantizationMapCapabilitiesKHR to id
+// VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR
+template <>
+struct LvlTypeMap<VkVideoEncodeAV1QuantizationMapCapabilitiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR> {
+    typedef VkVideoEncodeAV1QuantizationMapCapabilitiesKHR Type;
+};
+
+// Map type VkVideoFormatAV1QuantizationMapPropertiesKHR to id VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkVideoFormatAV1QuantizationMapPropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR> {
+    typedef VkVideoFormatAV1QuantizationMapPropertiesKHR Type;
+};
+
+// Map type VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR> {
+    typedef VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR Type;
+};
+
+// Map type VkPhysicalDeviceMaintenance7FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMaintenance7FeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR> {
+    typedef VkPhysicalDeviceMaintenance7FeaturesKHR Type;
+};
+
+// Map type VkPhysicalDeviceMaintenance7PropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMaintenance7PropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR> {
+    typedef VkPhysicalDeviceMaintenance7PropertiesKHR Type;
+};
+
+// Map type VkPhysicalDeviceLayeredApiPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceLayeredApiPropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR> {
+    typedef VkPhysicalDeviceLayeredApiPropertiesKHR Type;
+};
+
+// Map type VkPhysicalDeviceLayeredApiPropertiesListKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceLayeredApiPropertiesListKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR> {
+    typedef VkPhysicalDeviceLayeredApiPropertiesListKHR Type;
+};
+
+// Map type VkPhysicalDeviceLayeredApiVulkanPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceLayeredApiVulkanPropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR> {
+    typedef VkPhysicalDeviceLayeredApiVulkanPropertiesKHR Type;
+};
+
+// Map type VkPhysicalDeviceFaultFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceFaultFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR> {
+    typedef VkPhysicalDeviceFaultFeaturesKHR Type;
+};
+
+// Map type VkPhysicalDeviceFaultPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceFaultPropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_PROPERTIES_KHR> {
+    typedef VkPhysicalDeviceFaultPropertiesKHR Type;
+};
+
+// Map type VkDeviceFaultInfoKHR to id VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_KHR
+template <>
+struct LvlTypeMap<VkDeviceFaultInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_KHR> {
+    typedef VkDeviceFaultInfoKHR Type;
+};
+
+// Map type VkDeviceFaultDebugInfoKHR to id VK_STRUCTURE_TYPE_DEVICE_FAULT_DEBUG_INFO_KHR
+template <>
+struct LvlTypeMap<VkDeviceFaultDebugInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_FAULT_DEBUG_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_FAULT_DEBUG_INFO_KHR> {
+    typedef VkDeviceFaultDebugInfoKHR Type;
+};
+
+// Map type VkMemoryBarrierAccessFlags3KHR to id VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR
+template <>
+struct LvlTypeMap<VkMemoryBarrierAccessFlags3KHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR> {
+    typedef VkMemoryBarrierAccessFlags3KHR Type;
+};
+
+// Map type VkPhysicalDeviceMaintenance8FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMaintenance8FeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR> {
+    typedef VkPhysicalDeviceMaintenance8FeaturesKHR Type;
+};
+
+// Map type VkPhysicalDeviceShaderFmaFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderFmaFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR> {
+    typedef VkPhysicalDeviceShaderFmaFeaturesKHR Type;
+};
+
+// Map type VkPhysicalDeviceMaintenance9FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMaintenance9FeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR> {
+    typedef VkPhysicalDeviceMaintenance9FeaturesKHR Type;
+};
+
+// Map type VkPhysicalDeviceMaintenance9PropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMaintenance9PropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR> {
+    typedef VkPhysicalDeviceMaintenance9PropertiesKHR Type;
+};
+
+// Map type VkQueueFamilyOwnershipTransferPropertiesKHR to id VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkQueueFamilyOwnershipTransferPropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR> {
+    typedef VkQueueFamilyOwnershipTransferPropertiesKHR Type;
+};
+
+// Map type VkPhysicalDeviceVideoMaintenance2FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceVideoMaintenance2FeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR> {
+    typedef VkPhysicalDeviceVideoMaintenance2FeaturesKHR Type;
+};
+
+// Map type VkVideoDecodeH264InlineSessionParametersInfoKHR to id
+// VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeH264InlineSessionParametersInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR> {
+    typedef VkVideoDecodeH264InlineSessionParametersInfoKHR Type;
+};
+
+// Map type VkVideoDecodeH265InlineSessionParametersInfoKHR to id
+// VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeH265InlineSessionParametersInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR> {
+    typedef VkVideoDecodeH265InlineSessionParametersInfoKHR Type;
+};
+
+// Map type VkVideoDecodeAV1InlineSessionParametersInfoKHR to id
+// VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR
+template <>
+struct LvlTypeMap<VkVideoDecodeAV1InlineSessionParametersInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR> {
+    typedef VkVideoDecodeAV1InlineSessionParametersInfoKHR Type;
+};
+
+// Map type VkPhysicalDeviceDepthClampZeroOneFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDepthClampZeroOneFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR> {
+    typedef VkPhysicalDeviceDepthClampZeroOneFeaturesKHR Type;
+};
+
+// Map type VkPhysicalDeviceRobustness2FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceRobustness2FeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR> {
+    typedef VkPhysicalDeviceRobustness2FeaturesKHR Type;
+};
+
+// Map type VkPhysicalDeviceRobustness2PropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceRobustness2PropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR> {
+    typedef VkPhysicalDeviceRobustness2PropertiesKHR Type;
+};
+
+// Map type VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR> {
+    typedef VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR Type;
+};
+
+// Map type VkPhysicalDeviceMaintenance10FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMaintenance10FeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR> {
+    typedef VkPhysicalDeviceMaintenance10FeaturesKHR Type;
+};
+
+// Map type VkPhysicalDeviceMaintenance10PropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMaintenance10PropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR> {
+    typedef VkPhysicalDeviceMaintenance10PropertiesKHR Type;
+};
+
+// Map type VkRenderingEndInfoKHR to id VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR
+template <>
+struct LvlTypeMap<VkRenderingEndInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR> {
+    typedef VkRenderingEndInfoKHR Type;
+};
+
+// Map type VkRenderingAttachmentFlagsInfoKHR to id VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR
+template <>
+struct LvlTypeMap<VkRenderingAttachmentFlagsInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR> {
+    typedef VkRenderingAttachmentFlagsInfoKHR Type;
+};
+
+// Map type VkResolveImageModeInfoKHR to id VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR
+template <>
+struct LvlTypeMap<VkResolveImageModeInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR> {
+    typedef VkResolveImageModeInfoKHR Type;
+};
+
+// Map type VkDebugReportCallbackCreateInfoEXT to id VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkDebugReportCallbackCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT> {
+    typedef VkDebugReportCallbackCreateInfoEXT Type;
+};
+
+// Map type VkPipelineRasterizationStateRasterizationOrderAMD to id
+// VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD
+template <>
+struct LvlTypeMap<VkPipelineRasterizationStateRasterizationOrderAMD> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD> {
+    typedef VkPipelineRasterizationStateRasterizationOrderAMD Type;
+};
+
+// Map type VkDebugMarkerObjectNameInfoEXT to id VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT
+template <>
+struct LvlTypeMap<VkDebugMarkerObjectNameInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT> {
+    typedef VkDebugMarkerObjectNameInfoEXT Type;
+};
+
+// Map type VkDebugMarkerObjectTagInfoEXT to id VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT
+template <>
+struct LvlTypeMap<VkDebugMarkerObjectTagInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT> {
+    typedef VkDebugMarkerObjectTagInfoEXT Type;
+};
+
+// Map type VkDebugMarkerMarkerInfoEXT to id VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT
+template <>
+struct LvlTypeMap<VkDebugMarkerMarkerInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT> {
+    typedef VkDebugMarkerMarkerInfoEXT Type;
+};
+
+// Map type VkDedicatedAllocationImageCreateInfoNV to id VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkDedicatedAllocationImageCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV> {
+    typedef VkDedicatedAllocationImageCreateInfoNV Type;
+};
+
+// Map type VkDedicatedAllocationBufferCreateInfoNV to id VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkDedicatedAllocationBufferCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV> {
+    typedef VkDedicatedAllocationBufferCreateInfoNV Type;
+};
+
+// Map type VkDedicatedAllocationMemoryAllocateInfoNV to id VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV
+template <>
+struct LvlTypeMap<VkDedicatedAllocationMemoryAllocateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV> {
+    typedef VkDedicatedAllocationMemoryAllocateInfoNV Type;
+};
+
+// Map type VkPhysicalDeviceTransformFeedbackFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceTransformFeedbackFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT> {
+    typedef VkPhysicalDeviceTransformFeedbackFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceTransformFeedbackPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceTransformFeedbackPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceTransformFeedbackPropertiesEXT Type;
+};
+
+// Map type VkPipelineRasterizationStateStreamCreateInfoEXT to id
+// VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkPipelineRasterizationStateStreamCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT> {
+    typedef VkPipelineRasterizationStateStreamCreateInfoEXT Type;
+};
+
+// Map type VkCuModuleCreateInfoNVX to id VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX
+template <>
+struct LvlTypeMap<VkCuModuleCreateInfoNVX> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX> {
+    typedef VkCuModuleCreateInfoNVX Type;
+};
+
+// Map type VkCuModuleTexturingModeCreateInfoNVX to id VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX
+template <>
+struct LvlTypeMap<VkCuModuleTexturingModeCreateInfoNVX> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX> {
+    typedef VkCuModuleTexturingModeCreateInfoNVX Type;
+};
+
+// Map type VkCuFunctionCreateInfoNVX to id VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX
+template <>
+struct LvlTypeMap<VkCuFunctionCreateInfoNVX> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX> {
+    typedef VkCuFunctionCreateInfoNVX Type;
+};
+
+// Map type VkCuLaunchInfoNVX to id VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX
+template <>
+struct LvlTypeMap<VkCuLaunchInfoNVX> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX> {
+    typedef VkCuLaunchInfoNVX Type;
+};
+
+// Map type VkImageViewHandleInfoNVX to id VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX
+template <>
+struct LvlTypeMap<VkImageViewHandleInfoNVX> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX> {
+    typedef VkImageViewHandleInfoNVX Type;
+};
+
+// Map type VkImageViewAddressPropertiesNVX to id VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX
+template <>
+struct LvlTypeMap<VkImageViewAddressPropertiesNVX> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX> {
+    typedef VkImageViewAddressPropertiesNVX Type;
+};
+
+// Map type VkTextureLODGatherFormatPropertiesAMD to id VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD
+template <>
+struct LvlTypeMap<VkTextureLODGatherFormatPropertiesAMD> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD> {
+    typedef VkTextureLODGatherFormatPropertiesAMD Type;
+};
+
+#ifdef VK_USE_PLATFORM_GGP
+// Map type VkStreamDescriptorSurfaceCreateInfoGGP to id VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP
+template <>
+struct LvlTypeMap<VkStreamDescriptorSurfaceCreateInfoGGP> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP> {
+    typedef VkStreamDescriptorSurfaceCreateInfoGGP Type;
+};
+
+#endif  // VK_USE_PLATFORM_GGP
+// Map type VkPhysicalDeviceCornerSampledImageFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceCornerSampledImageFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV> {
+    typedef VkPhysicalDeviceCornerSampledImageFeaturesNV Type;
+};
+
+// Map type VkExternalMemoryImageCreateInfoNV to id VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkExternalMemoryImageCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV> {
+    typedef VkExternalMemoryImageCreateInfoNV Type;
+};
+
+// Map type VkExportMemoryAllocateInfoNV to id VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV
+template <>
+struct LvlTypeMap<VkExportMemoryAllocateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV> {
+    typedef VkExportMemoryAllocateInfoNV Type;
+};
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+// Map type VkImportMemoryWin32HandleInfoNV to id VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV
+template <>
+struct LvlTypeMap<VkImportMemoryWin32HandleInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV> {
+    typedef VkImportMemoryWin32HandleInfoNV Type;
+};
+
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+// Map type VkExportMemoryWin32HandleInfoNV to id VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV
+template <>
+struct LvlTypeMap<VkExportMemoryWin32HandleInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV> {
+    typedef VkExportMemoryWin32HandleInfoNV Type;
+};
+
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+// Map type VkWin32KeyedMutexAcquireReleaseInfoNV to id VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV
+template <>
+struct LvlTypeMap<VkWin32KeyedMutexAcquireReleaseInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV> {
+    typedef VkWin32KeyedMutexAcquireReleaseInfoNV Type;
+};
+
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+// Map type VkValidationFlagsEXT to id VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT
+template <>
+struct LvlTypeMap<VkValidationFlagsEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT> {
+    typedef VkValidationFlagsEXT Type;
+};
+
+#ifdef VK_USE_PLATFORM_VI_NN
+// Map type VkViSurfaceCreateInfoNN to id VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN
+template <>
+struct LvlTypeMap<VkViSurfaceCreateInfoNN> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN> {
+    typedef VkViSurfaceCreateInfoNN Type;
+};
+
+#endif  // VK_USE_PLATFORM_VI_NN
+// Map type VkImageViewASTCDecodeModeEXT to id VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT
+template <>
+struct LvlTypeMap<VkImageViewASTCDecodeModeEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT> {
+    typedef VkImageViewASTCDecodeModeEXT Type;
+};
+
+// Map type VkPhysicalDeviceASTCDecodeFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceASTCDecodeFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT> {
+    typedef VkPhysicalDeviceASTCDecodeFeaturesEXT Type;
+};
+
+// Map type VkConditionalRenderingBeginInfoEXT to id VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT
+template <>
+struct LvlTypeMap<VkConditionalRenderingBeginInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT> {
+    typedef VkConditionalRenderingBeginInfoEXT Type;
+};
+
+// Map type VkPhysicalDeviceConditionalRenderingFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceConditionalRenderingFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT> {
+    typedef VkPhysicalDeviceConditionalRenderingFeaturesEXT Type;
+};
+
+// Map type VkCommandBufferInheritanceConditionalRenderingInfoEXT to id
+// VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT
+template <>
+struct LvlTypeMap<VkCommandBufferInheritanceConditionalRenderingInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT> {
+    typedef VkCommandBufferInheritanceConditionalRenderingInfoEXT Type;
+};
+
+// Map type VkPipelineViewportWScalingStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkPipelineViewportWScalingStateCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV> {
+    typedef VkPipelineViewportWScalingStateCreateInfoNV Type;
+};
+
+// Map type VkSurfaceCapabilities2EXT to id VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT
+template <>
+struct LvlTypeMap<VkSurfaceCapabilities2EXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT> {
+    typedef VkSurfaceCapabilities2EXT Type;
+};
+
+// Map type VkDisplayPowerInfoEXT to id VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT
+template <>
+struct LvlTypeMap<VkDisplayPowerInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT> {
+    typedef VkDisplayPowerInfoEXT Type;
+};
+
+// Map type VkDeviceEventInfoEXT to id VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT
+template <>
+struct LvlTypeMap<VkDeviceEventInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT> {
+    typedef VkDeviceEventInfoEXT Type;
+};
+
+// Map type VkDisplayEventInfoEXT to id VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT
+template <>
+struct LvlTypeMap<VkDisplayEventInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT> {
+    typedef VkDisplayEventInfoEXT Type;
+};
+
+// Map type VkSwapchainCounterCreateInfoEXT to id VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkSwapchainCounterCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT> {
+    typedef VkSwapchainCounterCreateInfoEXT Type;
+};
+
+// Map type VkPresentTimesInfoGOOGLE to id VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE
+template <>
+struct LvlTypeMap<VkPresentTimesInfoGOOGLE> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE> {
+    typedef VkPresentTimesInfoGOOGLE Type;
+};
+
+// Map type VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX> {
+    typedef VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX Type;
+};
+
+// Map type VkMultiviewPerViewAttributesInfoNVX to id VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX
+template <>
+struct LvlTypeMap<VkMultiviewPerViewAttributesInfoNVX> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX> {
+    typedef VkMultiviewPerViewAttributesInfoNVX Type;
+};
+
+// Map type VkPipelineViewportSwizzleStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkPipelineViewportSwizzleStateCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV> {
+    typedef VkPipelineViewportSwizzleStateCreateInfoNV Type;
+};
+
+// Map type VkPhysicalDeviceDiscardRectanglePropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDiscardRectanglePropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceDiscardRectanglePropertiesEXT Type;
+};
+
+// Map type VkPipelineDiscardRectangleStateCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkPipelineDiscardRectangleStateCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT> {
+    typedef VkPipelineDiscardRectangleStateCreateInfoEXT Type;
+};
+
+// Map type VkPhysicalDeviceConservativeRasterizationPropertiesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceConservativeRasterizationPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceConservativeRasterizationPropertiesEXT Type;
+};
+
+// Map type VkPipelineRasterizationConservativeStateCreateInfoEXT to id
+// VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkPipelineRasterizationConservativeStateCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT> {
+    typedef VkPipelineRasterizationConservativeStateCreateInfoEXT Type;
+};
+
+// Map type VkPhysicalDeviceDepthClipEnableFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDepthClipEnableFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT> {
+    typedef VkPhysicalDeviceDepthClipEnableFeaturesEXT Type;
+};
+
+// Map type VkPipelineRasterizationDepthClipStateCreateInfoEXT to id
+// VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkPipelineRasterizationDepthClipStateCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT> {
+    typedef VkPipelineRasterizationDepthClipStateCreateInfoEXT Type;
+};
+
+// Map type VkHdrMetadataEXT to id VK_STRUCTURE_TYPE_HDR_METADATA_EXT
+template <>
+struct LvlTypeMap<VkHdrMetadataEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_HDR_METADATA_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_HDR_METADATA_EXT> {
+    typedef VkHdrMetadataEXT Type;
+};
+
+// Map type VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG
+template <>
+struct LvlTypeMap<VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG> {
+    typedef VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG Type;
+};
+
+#ifdef VK_USE_PLATFORM_IOS_MVK
+// Map type VkIOSSurfaceCreateInfoMVK to id VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK
+template <>
+struct LvlTypeMap<VkIOSSurfaceCreateInfoMVK> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK> {
+    typedef VkIOSSurfaceCreateInfoMVK Type;
+};
+
+#endif  // VK_USE_PLATFORM_IOS_MVK
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+// Map type VkMacOSSurfaceCreateInfoMVK to id VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK
+template <>
+struct LvlTypeMap<VkMacOSSurfaceCreateInfoMVK> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK> {
+    typedef VkMacOSSurfaceCreateInfoMVK Type;
+};
+
+#endif  // VK_USE_PLATFORM_MACOS_MVK
+// Map type VkDebugUtilsLabelEXT to id VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT
+template <>
+struct LvlTypeMap<VkDebugUtilsLabelEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT> {
+    typedef VkDebugUtilsLabelEXT Type;
+};
+
+// Map type VkDebugUtilsObjectNameInfoEXT to id VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT
+template <>
+struct LvlTypeMap<VkDebugUtilsObjectNameInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT> {
+    typedef VkDebugUtilsObjectNameInfoEXT Type;
+};
+
+// Map type VkDebugUtilsMessengerCallbackDataEXT to id VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT
+template <>
+struct LvlTypeMap<VkDebugUtilsMessengerCallbackDataEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT> {
+    typedef VkDebugUtilsMessengerCallbackDataEXT Type;
+};
+
+// Map type VkDebugUtilsMessengerCreateInfoEXT to id VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkDebugUtilsMessengerCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT> {
+    typedef VkDebugUtilsMessengerCreateInfoEXT Type;
+};
+
+// Map type VkDebugUtilsObjectTagInfoEXT to id VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT
+template <>
+struct LvlTypeMap<VkDebugUtilsObjectTagInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT> {
+    typedef VkDebugUtilsObjectTagInfoEXT Type;
+};
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+// Map type VkAndroidHardwareBufferUsageANDROID to id VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID
+template <>
+struct LvlTypeMap<VkAndroidHardwareBufferUsageANDROID> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID> {
+    typedef VkAndroidHardwareBufferUsageANDROID Type;
+};
+
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+// Map type VkAndroidHardwareBufferPropertiesANDROID to id VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID
+template <>
+struct LvlTypeMap<VkAndroidHardwareBufferPropertiesANDROID> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID> {
+    typedef VkAndroidHardwareBufferPropertiesANDROID Type;
+};
+
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+// Map type VkAndroidHardwareBufferFormatPropertiesANDROID to id VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID
+template <>
+struct LvlTypeMap<VkAndroidHardwareBufferFormatPropertiesANDROID> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID> {
+    typedef VkAndroidHardwareBufferFormatPropertiesANDROID Type;
+};
+
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+// Map type VkImportAndroidHardwareBufferInfoANDROID to id VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID
+template <>
+struct LvlTypeMap<VkImportAndroidHardwareBufferInfoANDROID> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID> {
+    typedef VkImportAndroidHardwareBufferInfoANDROID Type;
+};
+
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+// Map type VkMemoryGetAndroidHardwareBufferInfoANDROID to id VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID
+template <>
+struct LvlTypeMap<VkMemoryGetAndroidHardwareBufferInfoANDROID> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID> {
+    typedef VkMemoryGetAndroidHardwareBufferInfoANDROID Type;
+};
+
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+// Map type VkExternalFormatANDROID to id VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID
+template <>
+struct LvlTypeMap<VkExternalFormatANDROID> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID> {
+    typedef VkExternalFormatANDROID Type;
+};
+
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+// Map type VkAndroidHardwareBufferFormatProperties2ANDROID to id
+// VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID
+template <>
+struct LvlTypeMap<VkAndroidHardwareBufferFormatProperties2ANDROID> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID> {
+    typedef VkAndroidHardwareBufferFormatProperties2ANDROID Type;
+};
+
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+// Map type VkPhysicalDeviceShaderEnqueueFeaturesAMDX to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderEnqueueFeaturesAMDX> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX> {
+    typedef VkPhysicalDeviceShaderEnqueueFeaturesAMDX Type;
+};
+
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+// Map type VkPhysicalDeviceShaderEnqueuePropertiesAMDX to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderEnqueuePropertiesAMDX> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX> {
+    typedef VkPhysicalDeviceShaderEnqueuePropertiesAMDX Type;
+};
+
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+// Map type VkExecutionGraphPipelineScratchSizeAMDX to id VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX
+template <>
+struct LvlTypeMap<VkExecutionGraphPipelineScratchSizeAMDX> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX> {
+    typedef VkExecutionGraphPipelineScratchSizeAMDX Type;
+};
+
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+// Map type VkExecutionGraphPipelineCreateInfoAMDX to id VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX
+template <>
+struct LvlTypeMap<VkExecutionGraphPipelineCreateInfoAMDX> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX> {
+    typedef VkExecutionGraphPipelineCreateInfoAMDX Type;
+};
+
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+// Map type VkPipelineShaderStageNodeCreateInfoAMDX to id VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX
+template <>
+struct LvlTypeMap<VkPipelineShaderStageNodeCreateInfoAMDX> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX> {
+    typedef VkPipelineShaderStageNodeCreateInfoAMDX Type;
+};
+
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+// Map type VkTexelBufferDescriptorInfoEXT to id VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT
+template <>
+struct LvlTypeMap<VkTexelBufferDescriptorInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT> {
+    typedef VkTexelBufferDescriptorInfoEXT Type;
+};
+
+// Map type VkImageDescriptorInfoEXT to id VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT
+template <>
+struct LvlTypeMap<VkImageDescriptorInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT> {
+    typedef VkImageDescriptorInfoEXT Type;
+};
+
+// Map type VkTensorViewCreateInfoARM to id VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM
+template <>
+struct LvlTypeMap<VkTensorViewCreateInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM> {
+    typedef VkTensorViewCreateInfoARM Type;
+};
+
+// Map type VkResourceDescriptorInfoEXT to id VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT
+template <>
+struct LvlTypeMap<VkResourceDescriptorInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT> {
+    typedef VkResourceDescriptorInfoEXT Type;
+};
+
+// Map type VkBindHeapInfoEXT to id VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT
+template <>
+struct LvlTypeMap<VkBindHeapInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT> {
+    typedef VkBindHeapInfoEXT Type;
+};
+
+// Map type VkPushDataInfoEXT to id VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT
+template <>
+struct LvlTypeMap<VkPushDataInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT> {
+    typedef VkPushDataInfoEXT Type;
+};
+
+// Map type VkDescriptorSetAndBindingMappingEXT to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT
+template <>
+struct LvlTypeMap<VkDescriptorSetAndBindingMappingEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT> {
+    typedef VkDescriptorSetAndBindingMappingEXT Type;
+};
+
+// Map type VkShaderDescriptorSetAndBindingMappingInfoEXT to id VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT
+template <>
+struct LvlTypeMap<VkShaderDescriptorSetAndBindingMappingInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT> {
+    typedef VkShaderDescriptorSetAndBindingMappingInfoEXT Type;
+};
+
+// Map type VkOpaqueCaptureDataCreateInfoEXT to id VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkOpaqueCaptureDataCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT> {
+    typedef VkOpaqueCaptureDataCreateInfoEXT Type;
+};
+
+// Map type VkPhysicalDeviceDescriptorHeapFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDescriptorHeapFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT> {
+    typedef VkPhysicalDeviceDescriptorHeapFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceDescriptorHeapPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDescriptorHeapPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceDescriptorHeapPropertiesEXT Type;
+};
+
+// Map type VkCommandBufferInheritanceDescriptorHeapInfoEXT to id
+// VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT
+template <>
+struct LvlTypeMap<VkCommandBufferInheritanceDescriptorHeapInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT> {
+    typedef VkCommandBufferInheritanceDescriptorHeapInfoEXT Type;
+};
+
+// Map type VkSamplerCustomBorderColorIndexCreateInfoEXT to id VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkSamplerCustomBorderColorIndexCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT> {
+    typedef VkSamplerCustomBorderColorIndexCreateInfoEXT Type;
+};
+
+// Map type VkSamplerCustomBorderColorCreateInfoEXT to id VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkSamplerCustomBorderColorCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT> {
+    typedef VkSamplerCustomBorderColorCreateInfoEXT Type;
+};
+
+// Map type VkIndirectCommandsLayoutPushDataTokenNV to id VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV
+template <>
+struct LvlTypeMap<VkIndirectCommandsLayoutPushDataTokenNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV> {
+    typedef VkIndirectCommandsLayoutPushDataTokenNV Type;
+};
+
+// Map type VkSubsampledImageFormatPropertiesEXT to id VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkSubsampledImageFormatPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT> {
+    typedef VkSubsampledImageFormatPropertiesEXT Type;
+};
+
+// Map type VkPhysicalDeviceDescriptorHeapTensorPropertiesARM to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDescriptorHeapTensorPropertiesARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM> {
+    typedef VkPhysicalDeviceDescriptorHeapTensorPropertiesARM Type;
+};
+
+// Map type VkAttachmentSampleCountInfoAMD to id VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD
+template <>
+struct LvlTypeMap<VkAttachmentSampleCountInfoAMD> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD> {
+    typedef VkAttachmentSampleCountInfoAMD Type;
+};
+
+// Map type VkSampleLocationsInfoEXT to id VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT
+template <>
+struct LvlTypeMap<VkSampleLocationsInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT> {
+    typedef VkSampleLocationsInfoEXT Type;
+};
+
+// Map type VkRenderPassSampleLocationsBeginInfoEXT to id VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT
+template <>
+struct LvlTypeMap<VkRenderPassSampleLocationsBeginInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT> {
+    typedef VkRenderPassSampleLocationsBeginInfoEXT Type;
+};
+
+// Map type VkPipelineSampleLocationsStateCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkPipelineSampleLocationsStateCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT> {
+    typedef VkPipelineSampleLocationsStateCreateInfoEXT Type;
+};
+
+// Map type VkPhysicalDeviceSampleLocationsPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceSampleLocationsPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceSampleLocationsPropertiesEXT Type;
+};
+
+// Map type VkMultisamplePropertiesEXT to id VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkMultisamplePropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT> {
+    typedef VkMultisamplePropertiesEXT Type;
+};
+
+// Map type VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT> {
+    typedef VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT Type;
+};
+
+// Map type VkPipelineColorBlendAdvancedStateCreateInfoEXT to id
+// VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkPipelineColorBlendAdvancedStateCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT> {
+    typedef VkPipelineColorBlendAdvancedStateCreateInfoEXT Type;
+};
+
+// Map type VkPipelineCoverageToColorStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkPipelineCoverageToColorStateCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV> {
+    typedef VkPipelineCoverageToColorStateCreateInfoNV Type;
+};
+
+// Map type VkPipelineCoverageModulationStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkPipelineCoverageModulationStateCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV> {
+    typedef VkPipelineCoverageModulationStateCreateInfoNV Type;
+};
+
+// Map type VkPhysicalDeviceShaderSMBuiltinsPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV> {
+    typedef VkPhysicalDeviceShaderSMBuiltinsPropertiesNV Type;
+};
+
+// Map type VkPhysicalDeviceShaderSMBuiltinsFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV> {
+    typedef VkPhysicalDeviceShaderSMBuiltinsFeaturesNV Type;
+};
+
+// Map type VkDrmFormatModifierPropertiesListEXT to id VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT
+template <>
+struct LvlTypeMap<VkDrmFormatModifierPropertiesListEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT> {
+    typedef VkDrmFormatModifierPropertiesListEXT Type;
+};
+
+// Map type VkPhysicalDeviceImageDrmFormatModifierInfoEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceImageDrmFormatModifierInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT> {
+    typedef VkPhysicalDeviceImageDrmFormatModifierInfoEXT Type;
+};
+
+// Map type VkImageDrmFormatModifierListCreateInfoEXT to id VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkImageDrmFormatModifierListCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT> {
+    typedef VkImageDrmFormatModifierListCreateInfoEXT Type;
+};
+
+// Map type VkImageDrmFormatModifierExplicitCreateInfoEXT to id VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkImageDrmFormatModifierExplicitCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT> {
+    typedef VkImageDrmFormatModifierExplicitCreateInfoEXT Type;
+};
+
+// Map type VkImageDrmFormatModifierPropertiesEXT to id VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkImageDrmFormatModifierPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT> {
+    typedef VkImageDrmFormatModifierPropertiesEXT Type;
+};
+
+// Map type VkDrmFormatModifierPropertiesList2EXT to id VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT
+template <>
+struct LvlTypeMap<VkDrmFormatModifierPropertiesList2EXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT> {
+    typedef VkDrmFormatModifierPropertiesList2EXT Type;
+};
+
+// Map type VkValidationCacheCreateInfoEXT to id VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkValidationCacheCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT> {
+    typedef VkValidationCacheCreateInfoEXT Type;
+};
+
+// Map type VkShaderModuleValidationCacheCreateInfoEXT to id VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkShaderModuleValidationCacheCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT> {
+    typedef VkShaderModuleValidationCacheCreateInfoEXT Type;
+};
+
+// Map type VkPipelineViewportShadingRateImageStateCreateInfoNV to id
+// VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkPipelineViewportShadingRateImageStateCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV> {
+    typedef VkPipelineViewportShadingRateImageStateCreateInfoNV Type;
+};
+
+// Map type VkPhysicalDeviceShadingRateImageFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShadingRateImageFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV> {
+    typedef VkPhysicalDeviceShadingRateImageFeaturesNV Type;
+};
+
+// Map type VkPhysicalDeviceShadingRateImagePropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShadingRateImagePropertiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV> {
+    typedef VkPhysicalDeviceShadingRateImagePropertiesNV Type;
+};
+
+// Map type VkPipelineViewportCoarseSampleOrderStateCreateInfoNV to id
+// VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV> {
+    typedef VkPipelineViewportCoarseSampleOrderStateCreateInfoNV Type;
+};
+
+// Map type VkRayTracingShaderGroupCreateInfoNV to id VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkRayTracingShaderGroupCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV> {
+    typedef VkRayTracingShaderGroupCreateInfoNV Type;
+};
+
+// Map type VkRayTracingPipelineCreateInfoNV to id VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkRayTracingPipelineCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV> {
+    typedef VkRayTracingPipelineCreateInfoNV Type;
+};
+
+// Map type VkGeometryTrianglesNV to id VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV
+template <>
+struct LvlTypeMap<VkGeometryTrianglesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV> {
+    typedef VkGeometryTrianglesNV Type;
+};
+
+// Map type VkGeometryAABBNV to id VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV
+template <>
+struct LvlTypeMap<VkGeometryAABBNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV> {
+    typedef VkGeometryAABBNV Type;
+};
+
+// Map type VkGeometryNV to id VK_STRUCTURE_TYPE_GEOMETRY_NV
+template <>
+struct LvlTypeMap<VkGeometryNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_GEOMETRY_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_GEOMETRY_NV> {
+    typedef VkGeometryNV Type;
+};
+
+// Map type VkAccelerationStructureInfoNV to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV
+template <>
+struct LvlTypeMap<VkAccelerationStructureInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV> {
+    typedef VkAccelerationStructureInfoNV Type;
+};
+
+// Map type VkAccelerationStructureCreateInfoNV to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkAccelerationStructureCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV> {
+    typedef VkAccelerationStructureCreateInfoNV Type;
+};
+
+// Map type VkBindAccelerationStructureMemoryInfoNV to id VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV
+template <>
+struct LvlTypeMap<VkBindAccelerationStructureMemoryInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV> {
+    typedef VkBindAccelerationStructureMemoryInfoNV Type;
+};
+
+// Map type VkWriteDescriptorSetAccelerationStructureNV to id VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV
+template <>
+struct LvlTypeMap<VkWriteDescriptorSetAccelerationStructureNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV> {
+    typedef VkWriteDescriptorSetAccelerationStructureNV Type;
+};
+
+// Map type VkAccelerationStructureMemoryRequirementsInfoNV to id
+// VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV
+template <>
+struct LvlTypeMap<VkAccelerationStructureMemoryRequirementsInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV> {
+    typedef VkAccelerationStructureMemoryRequirementsInfoNV Type;
+};
+
+// Map type VkPhysicalDeviceRayTracingPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceRayTracingPropertiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV> {
+    typedef VkPhysicalDeviceRayTracingPropertiesNV Type;
+};
+
+// Map type VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV> {
+    typedef VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV Type;
+};
+
+// Map type VkPipelineRepresentativeFragmentTestStateCreateInfoNV to id
+// VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkPipelineRepresentativeFragmentTestStateCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV> {
+    typedef VkPipelineRepresentativeFragmentTestStateCreateInfoNV Type;
+};
+
+// Map type VkPhysicalDeviceImageViewImageFormatInfoEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceImageViewImageFormatInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT> {
+    typedef VkPhysicalDeviceImageViewImageFormatInfoEXT Type;
+};
+
+// Map type VkFilterCubicImageViewImageFormatPropertiesEXT to id
+// VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkFilterCubicImageViewImageFormatPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT> {
+    typedef VkFilterCubicImageViewImageFormatPropertiesEXT Type;
+};
+
+// Map type VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM> {
+    typedef VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM Type;
+};
+
+// Map type VkImportMemoryHostPointerInfoEXT to id VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT
+template <>
+struct LvlTypeMap<VkImportMemoryHostPointerInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT> {
+    typedef VkImportMemoryHostPointerInfoEXT Type;
+};
+
+// Map type VkMemoryHostPointerPropertiesEXT to id VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkMemoryHostPointerPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT> {
+    typedef VkMemoryHostPointerPropertiesEXT Type;
+};
+
+// Map type VkPhysicalDeviceExternalMemoryHostPropertiesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceExternalMemoryHostPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceExternalMemoryHostPropertiesEXT Type;
+};
+
+// Map type VkPipelineCompilerControlCreateInfoAMD to id VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD
+template <>
+struct LvlTypeMap<VkPipelineCompilerControlCreateInfoAMD> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD> {
+    typedef VkPipelineCompilerControlCreateInfoAMD Type;
+};
+
+// Map type VkPhysicalDeviceShaderCorePropertiesAMD to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderCorePropertiesAMD> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD> {
+    typedef VkPhysicalDeviceShaderCorePropertiesAMD Type;
+};
+
+// Map type VkDeviceMemoryOverallocationCreateInfoAMD to id VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD
+template <>
+struct LvlTypeMap<VkDeviceMemoryOverallocationCreateInfoAMD> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD> {
+    typedef VkDeviceMemoryOverallocationCreateInfoAMD Type;
+};
+
+// Map type VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT Type;
+};
+
+#ifdef VK_USE_PLATFORM_GGP
+// Map type VkPresentFrameTokenGGP to id VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP
+template <>
+struct LvlTypeMap<VkPresentFrameTokenGGP> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP> {
+    typedef VkPresentFrameTokenGGP Type;
+};
+
+#endif  // VK_USE_PLATFORM_GGP
+// Map type VkPhysicalDeviceMeshShaderFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMeshShaderFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV> {
+    typedef VkPhysicalDeviceMeshShaderFeaturesNV Type;
+};
+
+// Map type VkPhysicalDeviceMeshShaderPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMeshShaderPropertiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV> {
+    typedef VkPhysicalDeviceMeshShaderPropertiesNV Type;
+};
+
+// Map type VkPhysicalDeviceShaderImageFootprintFeaturesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderImageFootprintFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV> {
+    typedef VkPhysicalDeviceShaderImageFootprintFeaturesNV Type;
+};
+
+// Map type VkPipelineViewportExclusiveScissorStateCreateInfoNV to id
+// VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkPipelineViewportExclusiveScissorStateCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV> {
+    typedef VkPipelineViewportExclusiveScissorStateCreateInfoNV Type;
+};
+
+// Map type VkPhysicalDeviceExclusiveScissorFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceExclusiveScissorFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV> {
+    typedef VkPhysicalDeviceExclusiveScissorFeaturesNV Type;
+};
+
+// Map type VkQueueFamilyCheckpointPropertiesNV to id VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV
+template <>
+struct LvlTypeMap<VkQueueFamilyCheckpointPropertiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV> {
+    typedef VkQueueFamilyCheckpointPropertiesNV Type;
+};
+
+// Map type VkCheckpointDataNV to id VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV
+template <>
+struct LvlTypeMap<VkCheckpointDataNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV> {
+    typedef VkCheckpointDataNV Type;
+};
+
+// Map type VkQueueFamilyCheckpointProperties2NV to id VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV
+template <>
+struct LvlTypeMap<VkQueueFamilyCheckpointProperties2NV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV> {
+    typedef VkQueueFamilyCheckpointProperties2NV Type;
+};
+
+// Map type VkCheckpointData2NV to id VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV
+template <>
+struct LvlTypeMap<VkCheckpointData2NV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV> {
+    typedef VkCheckpointData2NV Type;
+};
+
+// Map type VkPhysicalDevicePresentTimingFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDevicePresentTimingFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT> {
+    typedef VkPhysicalDevicePresentTimingFeaturesEXT Type;
+};
+
+// Map type VkPresentTimingSurfaceCapabilitiesEXT to id VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT
+template <>
+struct LvlTypeMap<VkPresentTimingSurfaceCapabilitiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT> {
+    typedef VkPresentTimingSurfaceCapabilitiesEXT Type;
+};
+
+// Map type VkSwapchainCalibratedTimestampInfoEXT to id VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT
+template <>
+struct LvlTypeMap<VkSwapchainCalibratedTimestampInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT> {
+    typedef VkSwapchainCalibratedTimestampInfoEXT Type;
+};
+
+// Map type VkSwapchainTimingPropertiesEXT to id VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkSwapchainTimingPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT> {
+    typedef VkSwapchainTimingPropertiesEXT Type;
+};
+
+// Map type VkSwapchainTimeDomainPropertiesEXT to id VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkSwapchainTimeDomainPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT> {
+    typedef VkSwapchainTimeDomainPropertiesEXT Type;
+};
+
+// Map type VkPastPresentationTimingInfoEXT to id VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT
+template <>
+struct LvlTypeMap<VkPastPresentationTimingInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT> {
+    typedef VkPastPresentationTimingInfoEXT Type;
+};
+
+// Map type VkPastPresentationTimingEXT to id VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT
+template <>
+struct LvlTypeMap<VkPastPresentationTimingEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT> {
+    typedef VkPastPresentationTimingEXT Type;
+};
+
+// Map type VkPastPresentationTimingPropertiesEXT to id VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPastPresentationTimingPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT> {
+    typedef VkPastPresentationTimingPropertiesEXT Type;
+};
+
+// Map type VkPresentTimingInfoEXT to id VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT
+template <>
+struct LvlTypeMap<VkPresentTimingInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT> {
+    typedef VkPresentTimingInfoEXT Type;
+};
+
+// Map type VkPresentTimingsInfoEXT to id VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT
+template <>
+struct LvlTypeMap<VkPresentTimingsInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT> {
+    typedef VkPresentTimingsInfoEXT Type;
+};
+
+// Map type VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL> {
+    typedef VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL Type;
+};
+
+// Map type VkInitializePerformanceApiInfoINTEL to id VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL
+template <>
+struct LvlTypeMap<VkInitializePerformanceApiInfoINTEL> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL> {
+    typedef VkInitializePerformanceApiInfoINTEL Type;
+};
+
+// Map type VkQueryPoolPerformanceQueryCreateInfoINTEL to id VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL
+template <>
+struct LvlTypeMap<VkQueryPoolPerformanceQueryCreateInfoINTEL> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL> {
+    typedef VkQueryPoolPerformanceQueryCreateInfoINTEL Type;
+};
+
+// Map type VkPerformanceMarkerInfoINTEL to id VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL
+template <>
+struct LvlTypeMap<VkPerformanceMarkerInfoINTEL> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL> {
+    typedef VkPerformanceMarkerInfoINTEL Type;
+};
+
+// Map type VkPerformanceStreamMarkerInfoINTEL to id VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL
+template <>
+struct LvlTypeMap<VkPerformanceStreamMarkerInfoINTEL> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL> {
+    typedef VkPerformanceStreamMarkerInfoINTEL Type;
+};
+
+// Map type VkPerformanceOverrideInfoINTEL to id VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL
+template <>
+struct LvlTypeMap<VkPerformanceOverrideInfoINTEL> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL> {
+    typedef VkPerformanceOverrideInfoINTEL Type;
+};
+
+// Map type VkPerformanceConfigurationAcquireInfoINTEL to id VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL
+template <>
+struct LvlTypeMap<VkPerformanceConfigurationAcquireInfoINTEL> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL> {
+    typedef VkPerformanceConfigurationAcquireInfoINTEL Type;
+};
+
+// Map type VkPhysicalDevicePCIBusInfoPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDevicePCIBusInfoPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT> {
+    typedef VkPhysicalDevicePCIBusInfoPropertiesEXT Type;
+};
+
+// Map type VkDisplayNativeHdrSurfaceCapabilitiesAMD to id VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD
+template <>
+struct LvlTypeMap<VkDisplayNativeHdrSurfaceCapabilitiesAMD> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD> {
+    typedef VkDisplayNativeHdrSurfaceCapabilitiesAMD Type;
+};
+
+// Map type VkSwapchainDisplayNativeHdrCreateInfoAMD to id VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD
+template <>
+struct LvlTypeMap<VkSwapchainDisplayNativeHdrCreateInfoAMD> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD> {
+    typedef VkSwapchainDisplayNativeHdrCreateInfoAMD Type;
+};
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkImagePipeSurfaceCreateInfoFUCHSIA to id VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA
+template <>
+struct LvlTypeMap<VkImagePipeSurfaceCreateInfoFUCHSIA> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA> {
+    typedef VkImagePipeSurfaceCreateInfoFUCHSIA Type;
+};
+
+#endif  // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_METAL_EXT
+// Map type VkMetalSurfaceCreateInfoEXT to id VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkMetalSurfaceCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT> {
+    typedef VkMetalSurfaceCreateInfoEXT Type;
+};
+
+#endif  // VK_USE_PLATFORM_METAL_EXT
+// Map type VkPhysicalDeviceFragmentDensityMapFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceFragmentDensityMapFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT> {
+    typedef VkPhysicalDeviceFragmentDensityMapFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceFragmentDensityMapPropertiesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceFragmentDensityMapPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceFragmentDensityMapPropertiesEXT Type;
+};
+
+// Map type VkRenderPassFragmentDensityMapCreateInfoEXT to id VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkRenderPassFragmentDensityMapCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT> {
+    typedef VkRenderPassFragmentDensityMapCreateInfoEXT Type;
+};
+
+// Map type VkRenderingFragmentDensityMapAttachmentInfoEXT to id
+// VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT
+template <>
+struct LvlTypeMap<VkRenderingFragmentDensityMapAttachmentInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT> {
+    typedef VkRenderingFragmentDensityMapAttachmentInfoEXT Type;
+};
+
+// Map type VkPhysicalDeviceShaderCoreProperties2AMD to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderCoreProperties2AMD> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD> {
+    typedef VkPhysicalDeviceShaderCoreProperties2AMD Type;
+};
+
+// Map type VkPhysicalDeviceCoherentMemoryFeaturesAMD to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD
+template <>
+struct LvlTypeMap<VkPhysicalDeviceCoherentMemoryFeaturesAMD> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD> {
+    typedef VkPhysicalDeviceCoherentMemoryFeaturesAMD Type;
+};
+
+// Map type VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT> {
+    typedef VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceMemoryBudgetPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMemoryBudgetPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceMemoryBudgetPropertiesEXT Type;
+};
+
+// Map type VkPhysicalDeviceMemoryPriorityFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMemoryPriorityFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT> {
+    typedef VkPhysicalDeviceMemoryPriorityFeaturesEXT Type;
+};
+
+// Map type VkMemoryPriorityAllocateInfoEXT to id VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkMemoryPriorityAllocateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT> {
+    typedef VkMemoryPriorityAllocateInfoEXT Type;
+};
+
+// Map type VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV> {
+    typedef VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV Type;
+};
+
+// Map type VkPhysicalDeviceBufferDeviceAddressFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT> {
+    typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT Type;
+};
+
+// Map type VkBufferDeviceAddressCreateInfoEXT to id VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkBufferDeviceAddressCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT> {
+    typedef VkBufferDeviceAddressCreateInfoEXT Type;
+};
+
+// Map type VkValidationFeaturesEXT to id VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkValidationFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT> {
+    typedef VkValidationFeaturesEXT Type;
+};
+
+// Map type VkCooperativeMatrixPropertiesNV to id VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV
+template <>
+struct LvlTypeMap<VkCooperativeMatrixPropertiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV> {
+    typedef VkCooperativeMatrixPropertiesNV Type;
+};
+
+// Map type VkPhysicalDeviceCooperativeMatrixFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceCooperativeMatrixFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV> {
+    typedef VkPhysicalDeviceCooperativeMatrixFeaturesNV Type;
+};
+
+// Map type VkPhysicalDeviceCooperativeMatrixPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceCooperativeMatrixPropertiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV> {
+    typedef VkPhysicalDeviceCooperativeMatrixPropertiesNV Type;
+};
+
+// Map type VkPhysicalDeviceCoverageReductionModeFeaturesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceCoverageReductionModeFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV> {
+    typedef VkPhysicalDeviceCoverageReductionModeFeaturesNV Type;
+};
+
+// Map type VkPipelineCoverageReductionStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkPipelineCoverageReductionStateCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV> {
+    typedef VkPipelineCoverageReductionStateCreateInfoNV Type;
+};
+
+// Map type VkFramebufferMixedSamplesCombinationNV to id VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV
+template <>
+struct LvlTypeMap<VkFramebufferMixedSamplesCombinationNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV> {
+    typedef VkFramebufferMixedSamplesCombinationNV Type;
+};
+
+// Map type VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT> {
+    typedef VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceYcbcrImageArraysFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT> {
+    typedef VkPhysicalDeviceYcbcrImageArraysFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceProvokingVertexFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceProvokingVertexFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT> {
+    typedef VkPhysicalDeviceProvokingVertexFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceProvokingVertexPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceProvokingVertexPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceProvokingVertexPropertiesEXT Type;
+};
+
+// Map type VkPipelineRasterizationProvokingVertexStateCreateInfoEXT to id
+// VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkPipelineRasterizationProvokingVertexStateCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT> {
+    typedef VkPipelineRasterizationProvokingVertexStateCreateInfoEXT Type;
+};
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+// Map type VkSurfaceFullScreenExclusiveInfoEXT to id VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT
+template <>
+struct LvlTypeMap<VkSurfaceFullScreenExclusiveInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT> {
+    typedef VkSurfaceFullScreenExclusiveInfoEXT Type;
+};
+
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+// Map type VkSurfaceCapabilitiesFullScreenExclusiveEXT to id VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT
+template <>
+struct LvlTypeMap<VkSurfaceCapabilitiesFullScreenExclusiveEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT> {
+    typedef VkSurfaceCapabilitiesFullScreenExclusiveEXT Type;
+};
+
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+// Map type VkSurfaceFullScreenExclusiveWin32InfoEXT to id VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT
+template <>
+struct LvlTypeMap<VkSurfaceFullScreenExclusiveWin32InfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT> {
+    typedef VkSurfaceFullScreenExclusiveWin32InfoEXT Type;
+};
+
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+// Map type VkHeadlessSurfaceCreateInfoEXT to id VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkHeadlessSurfaceCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT> {
+    typedef VkHeadlessSurfaceCreateInfoEXT Type;
+};
+
+// Map type VkPhysicalDeviceShaderAtomicFloatFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT> {
+    typedef VkPhysicalDeviceShaderAtomicFloatFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceExtendedDynamicStateFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT> {
+    typedef VkPhysicalDeviceExtendedDynamicStateFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceMapMemoryPlacedFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMapMemoryPlacedFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT> {
+    typedef VkPhysicalDeviceMapMemoryPlacedFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceMapMemoryPlacedPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMapMemoryPlacedPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceMapMemoryPlacedPropertiesEXT Type;
+};
+
+// Map type VkMemoryMapPlacedInfoEXT to id VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT
+template <>
+struct LvlTypeMap<VkMemoryMapPlacedInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT> {
+    typedef VkMemoryMapPlacedInfoEXT Type;
+};
+
+// Map type VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT> {
+    typedef VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV> {
+    typedef VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV Type;
+};
+
+// Map type VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV> {
+    typedef VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV Type;
+};
+
+// Map type VkGraphicsShaderGroupCreateInfoNV to id VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkGraphicsShaderGroupCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV> {
+    typedef VkGraphicsShaderGroupCreateInfoNV Type;
+};
+
+// Map type VkGraphicsPipelineShaderGroupsCreateInfoNV to id VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkGraphicsPipelineShaderGroupsCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV> {
+    typedef VkGraphicsPipelineShaderGroupsCreateInfoNV Type;
+};
+
+// Map type VkIndirectCommandsLayoutTokenNV to id VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV
+template <>
+struct LvlTypeMap<VkIndirectCommandsLayoutTokenNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV> {
+    typedef VkIndirectCommandsLayoutTokenNV Type;
+};
+
+// Map type VkIndirectCommandsLayoutCreateInfoNV to id VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkIndirectCommandsLayoutCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV> {
+    typedef VkIndirectCommandsLayoutCreateInfoNV Type;
+};
+
+// Map type VkGeneratedCommandsInfoNV to id VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV
+template <>
+struct LvlTypeMap<VkGeneratedCommandsInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV> {
+    typedef VkGeneratedCommandsInfoNV Type;
+};
+
+// Map type VkGeneratedCommandsMemoryRequirementsInfoNV to id VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV
+template <>
+struct LvlTypeMap<VkGeneratedCommandsMemoryRequirementsInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV> {
+    typedef VkGeneratedCommandsMemoryRequirementsInfoNV Type;
+};
+
+// Map type VkPhysicalDeviceInheritedViewportScissorFeaturesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceInheritedViewportScissorFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV> {
+    typedef VkPhysicalDeviceInheritedViewportScissorFeaturesNV Type;
+};
+
+// Map type VkCommandBufferInheritanceViewportScissorInfoNV to id
+// VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV
+template <>
+struct LvlTypeMap<VkCommandBufferInheritanceViewportScissorInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV> {
+    typedef VkCommandBufferInheritanceViewportScissorInfoNV Type;
+};
+
+// Map type VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT> {
+    typedef VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT Type;
+};
+
+// Map type VkRenderPassTransformBeginInfoQCOM to id VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM
+template <>
+struct LvlTypeMap<VkRenderPassTransformBeginInfoQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM> {
+    typedef VkRenderPassTransformBeginInfoQCOM Type;
+};
+
+// Map type VkCommandBufferInheritanceRenderPassTransformInfoQCOM to id
+// VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM
+template <>
+struct LvlTypeMap<VkCommandBufferInheritanceRenderPassTransformInfoQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM> {
+    typedef VkCommandBufferInheritanceRenderPassTransformInfoQCOM Type;
+};
+
+// Map type VkPhysicalDeviceDepthBiasControlFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDepthBiasControlFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT> {
+    typedef VkPhysicalDeviceDepthBiasControlFeaturesEXT Type;
+};
+
+// Map type VkDepthBiasInfoEXT to id VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT
+template <>
+struct LvlTypeMap<VkDepthBiasInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT> {
+    typedef VkDepthBiasInfoEXT Type;
+};
+
+// Map type VkDepthBiasRepresentationInfoEXT to id VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT
+template <>
+struct LvlTypeMap<VkDepthBiasRepresentationInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT> {
+    typedef VkDepthBiasRepresentationInfoEXT Type;
+};
+
+// Map type VkPhysicalDeviceDeviceMemoryReportFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT> {
+    typedef VkPhysicalDeviceDeviceMemoryReportFeaturesEXT Type;
+};
+
+// Map type VkDeviceMemoryReportCallbackDataEXT to id VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT
+template <>
+struct LvlTypeMap<VkDeviceMemoryReportCallbackDataEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT> {
+    typedef VkDeviceMemoryReportCallbackDataEXT Type;
+};
+
+// Map type VkDeviceDeviceMemoryReportCreateInfoEXT to id VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkDeviceDeviceMemoryReportCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT> {
+    typedef VkDeviceDeviceMemoryReportCreateInfoEXT Type;
+};
+
+// Map type VkPhysicalDeviceCustomBorderColorPropertiesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceCustomBorderColorPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceCustomBorderColorPropertiesEXT Type;
+};
+
+// Map type VkPhysicalDeviceCustomBorderColorFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceCustomBorderColorFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT> {
+    typedef VkPhysicalDeviceCustomBorderColorFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT> {
+    typedef VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDevicePresentBarrierFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDevicePresentBarrierFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV> {
+    typedef VkPhysicalDevicePresentBarrierFeaturesNV Type;
+};
+
+// Map type VkSurfaceCapabilitiesPresentBarrierNV to id VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV
+template <>
+struct LvlTypeMap<VkSurfaceCapabilitiesPresentBarrierNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV> {
+    typedef VkSurfaceCapabilitiesPresentBarrierNV Type;
+};
+
+// Map type VkSwapchainPresentBarrierCreateInfoNV to id VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkSwapchainPresentBarrierCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV> {
+    typedef VkSwapchainPresentBarrierCreateInfoNV Type;
+};
+
+// Map type VkPhysicalDeviceDiagnosticsConfigFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDiagnosticsConfigFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV> {
+    typedef VkPhysicalDeviceDiagnosticsConfigFeaturesNV Type;
+};
+
+// Map type VkDeviceDiagnosticsConfigCreateInfoNV to id VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkDeviceDiagnosticsConfigCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV> {
+    typedef VkDeviceDiagnosticsConfigCreateInfoNV Type;
+};
+
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+// Map type VkCudaModuleCreateInfoNV to id VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkCudaModuleCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV> {
+    typedef VkCudaModuleCreateInfoNV Type;
+};
+
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+// Map type VkCudaFunctionCreateInfoNV to id VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkCudaFunctionCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV> {
+    typedef VkCudaFunctionCreateInfoNV Type;
+};
+
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+// Map type VkCudaLaunchInfoNV to id VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV
+template <>
+struct LvlTypeMap<VkCudaLaunchInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV> {
+    typedef VkCudaLaunchInfoNV Type;
+};
+
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+// Map type VkPhysicalDeviceCudaKernelLaunchFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceCudaKernelLaunchFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV> {
+    typedef VkPhysicalDeviceCudaKernelLaunchFeaturesNV Type;
+};
+
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+// Map type VkPhysicalDeviceCudaKernelLaunchPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceCudaKernelLaunchPropertiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV> {
+    typedef VkPhysicalDeviceCudaKernelLaunchPropertiesNV Type;
+};
+
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+// Map type VkPhysicalDeviceTileShadingFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceTileShadingFeaturesQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM> {
+    typedef VkPhysicalDeviceTileShadingFeaturesQCOM Type;
+};
+
+// Map type VkPhysicalDeviceTileShadingPropertiesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceTileShadingPropertiesQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM> {
+    typedef VkPhysicalDeviceTileShadingPropertiesQCOM Type;
+};
+
+// Map type VkRenderPassTileShadingCreateInfoQCOM to id VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM
+template <>
+struct LvlTypeMap<VkRenderPassTileShadingCreateInfoQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM> {
+    typedef VkRenderPassTileShadingCreateInfoQCOM Type;
+};
+
+// Map type VkPerTileBeginInfoQCOM to id VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM
+template <>
+struct LvlTypeMap<VkPerTileBeginInfoQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM> {
+    typedef VkPerTileBeginInfoQCOM Type;
+};
+
+// Map type VkPerTileEndInfoQCOM to id VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM
+template <>
+struct LvlTypeMap<VkPerTileEndInfoQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM> {
+    typedef VkPerTileEndInfoQCOM Type;
+};
+
+// Map type VkDispatchTileInfoQCOM to id VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM
+template <>
+struct LvlTypeMap<VkDispatchTileInfoQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM> {
+    typedef VkDispatchTileInfoQCOM Type;
+};
+
+// Map type VkQueryLowLatencySupportNV to id VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV
+template <>
+struct LvlTypeMap<VkQueryLowLatencySupportNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV> {
+    typedef VkQueryLowLatencySupportNV Type;
+};
+
+#ifdef VK_USE_PLATFORM_METAL_EXT
+// Map type VkExportMetalObjectCreateInfoEXT to id VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkExportMetalObjectCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT> {
+    typedef VkExportMetalObjectCreateInfoEXT Type;
+};
+
+#endif  // VK_USE_PLATFORM_METAL_EXT
+#ifdef VK_USE_PLATFORM_METAL_EXT
+// Map type VkExportMetalObjectsInfoEXT to id VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT
+template <>
+struct LvlTypeMap<VkExportMetalObjectsInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT> {
+    typedef VkExportMetalObjectsInfoEXT Type;
+};
+
+#endif  // VK_USE_PLATFORM_METAL_EXT
+#ifdef VK_USE_PLATFORM_METAL_EXT
+// Map type VkExportMetalDeviceInfoEXT to id VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT
+template <>
+struct LvlTypeMap<VkExportMetalDeviceInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT> {
+    typedef VkExportMetalDeviceInfoEXT Type;
+};
+
+#endif  // VK_USE_PLATFORM_METAL_EXT
+#ifdef VK_USE_PLATFORM_METAL_EXT
+// Map type VkExportMetalCommandQueueInfoEXT to id VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT
+template <>
+struct LvlTypeMap<VkExportMetalCommandQueueInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT> {
+    typedef VkExportMetalCommandQueueInfoEXT Type;
+};
+
+#endif  // VK_USE_PLATFORM_METAL_EXT
+#ifdef VK_USE_PLATFORM_METAL_EXT
+// Map type VkExportMetalBufferInfoEXT to id VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT
+template <>
+struct LvlTypeMap<VkExportMetalBufferInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT> {
+    typedef VkExportMetalBufferInfoEXT Type;
+};
+
+#endif  // VK_USE_PLATFORM_METAL_EXT
+#ifdef VK_USE_PLATFORM_METAL_EXT
+// Map type VkImportMetalBufferInfoEXT to id VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT
+template <>
+struct LvlTypeMap<VkImportMetalBufferInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT> {
+    typedef VkImportMetalBufferInfoEXT Type;
+};
+
+#endif  // VK_USE_PLATFORM_METAL_EXT
+#ifdef VK_USE_PLATFORM_METAL_EXT
+// Map type VkExportMetalTextureInfoEXT to id VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT
+template <>
+struct LvlTypeMap<VkExportMetalTextureInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT> {
+    typedef VkExportMetalTextureInfoEXT Type;
+};
+
+#endif  // VK_USE_PLATFORM_METAL_EXT
+#ifdef VK_USE_PLATFORM_METAL_EXT
+// Map type VkImportMetalTextureInfoEXT to id VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT
+template <>
+struct LvlTypeMap<VkImportMetalTextureInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT> {
+    typedef VkImportMetalTextureInfoEXT Type;
+};
+
+#endif  // VK_USE_PLATFORM_METAL_EXT
+#ifdef VK_USE_PLATFORM_METAL_EXT
+// Map type VkExportMetalIOSurfaceInfoEXT to id VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT
+template <>
+struct LvlTypeMap<VkExportMetalIOSurfaceInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT> {
+    typedef VkExportMetalIOSurfaceInfoEXT Type;
+};
+
+#endif  // VK_USE_PLATFORM_METAL_EXT
+#ifdef VK_USE_PLATFORM_METAL_EXT
+// Map type VkImportMetalIOSurfaceInfoEXT to id VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT
+template <>
+struct LvlTypeMap<VkImportMetalIOSurfaceInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT> {
+    typedef VkImportMetalIOSurfaceInfoEXT Type;
+};
+
+#endif  // VK_USE_PLATFORM_METAL_EXT
+#ifdef VK_USE_PLATFORM_METAL_EXT
+// Map type VkExportMetalSharedEventInfoEXT to id VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT
+template <>
+struct LvlTypeMap<VkExportMetalSharedEventInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT> {
+    typedef VkExportMetalSharedEventInfoEXT Type;
+};
+
+#endif  // VK_USE_PLATFORM_METAL_EXT
+#ifdef VK_USE_PLATFORM_METAL_EXT
+// Map type VkImportMetalSharedEventInfoEXT to id VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT
+template <>
+struct LvlTypeMap<VkImportMetalSharedEventInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT> {
+    typedef VkImportMetalSharedEventInfoEXT Type;
+};
+
+#endif  // VK_USE_PLATFORM_METAL_EXT
+// Map type VkPhysicalDeviceDescriptorBufferPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDescriptorBufferPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceDescriptorBufferPropertiesEXT Type;
+};
+
+// Map type VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT Type;
+};
+
+// Map type VkPhysicalDeviceDescriptorBufferFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDescriptorBufferFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT> {
+    typedef VkPhysicalDeviceDescriptorBufferFeaturesEXT Type;
+};
+
+// Map type VkDescriptorAddressInfoEXT to id VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT
+template <>
+struct LvlTypeMap<VkDescriptorAddressInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT> {
+    typedef VkDescriptorAddressInfoEXT Type;
+};
+
+// Map type VkDescriptorBufferBindingInfoEXT to id VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT
+template <>
+struct LvlTypeMap<VkDescriptorBufferBindingInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT> {
+    typedef VkDescriptorBufferBindingInfoEXT Type;
+};
+
+// Map type VkDescriptorBufferBindingPushDescriptorBufferHandleEXT to id
+// VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT
+template <>
+struct LvlTypeMap<VkDescriptorBufferBindingPushDescriptorBufferHandleEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT> {
+    typedef VkDescriptorBufferBindingPushDescriptorBufferHandleEXT Type;
+};
+
+// Map type VkDescriptorGetInfoEXT to id VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT
+template <>
+struct LvlTypeMap<VkDescriptorGetInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT> {
+    typedef VkDescriptorGetInfoEXT Type;
+};
+
+// Map type VkBufferCaptureDescriptorDataInfoEXT to id VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT
+template <>
+struct LvlTypeMap<VkBufferCaptureDescriptorDataInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT> {
+    typedef VkBufferCaptureDescriptorDataInfoEXT Type;
+};
+
+// Map type VkImageCaptureDescriptorDataInfoEXT to id VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT
+template <>
+struct LvlTypeMap<VkImageCaptureDescriptorDataInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT> {
+    typedef VkImageCaptureDescriptorDataInfoEXT Type;
+};
+
+// Map type VkImageViewCaptureDescriptorDataInfoEXT to id VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT
+template <>
+struct LvlTypeMap<VkImageViewCaptureDescriptorDataInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT> {
+    typedef VkImageViewCaptureDescriptorDataInfoEXT Type;
+};
+
+// Map type VkSamplerCaptureDescriptorDataInfoEXT to id VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT
+template <>
+struct LvlTypeMap<VkSamplerCaptureDescriptorDataInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT> {
+    typedef VkSamplerCaptureDescriptorDataInfoEXT Type;
+};
+
+// Map type VkOpaqueCaptureDescriptorDataCreateInfoEXT to id VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkOpaqueCaptureDescriptorDataCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT> {
+    typedef VkOpaqueCaptureDescriptorDataCreateInfoEXT Type;
+};
+
+// Map type VkAccelerationStructureCaptureDescriptorDataInfoEXT to id
+// VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT
+template <>
+struct LvlTypeMap<VkAccelerationStructureCaptureDescriptorDataInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT> {
+    typedef VkAccelerationStructureCaptureDescriptorDataInfoEXT Type;
+};
+
+// Map type VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT> {
+    typedef VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT Type;
+};
+
+// Map type VkGraphicsPipelineLibraryCreateInfoEXT to id VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkGraphicsPipelineLibraryCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT> {
+    typedef VkGraphicsPipelineLibraryCreateInfoEXT Type;
+};
+
+// Map type VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD> {
+    typedef VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD Type;
+};
+
+// Map type VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV> {
+    typedef VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV Type;
+};
+
+// Map type VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV> {
+    typedef VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV Type;
+};
+
+// Map type VkPipelineFragmentShadingRateEnumStateCreateInfoNV to id
+// VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkPipelineFragmentShadingRateEnumStateCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV> {
+    typedef VkPipelineFragmentShadingRateEnumStateCreateInfoNV Type;
+};
+
+// Map type VkAccelerationStructureGeometryMotionTrianglesDataNV to id
+// VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV
+template <>
+struct LvlTypeMap<VkAccelerationStructureGeometryMotionTrianglesDataNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV> {
+    typedef VkAccelerationStructureGeometryMotionTrianglesDataNV Type;
+};
+
+// Map type VkAccelerationStructureMotionInfoNV to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV
+template <>
+struct LvlTypeMap<VkAccelerationStructureMotionInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV> {
+    typedef VkAccelerationStructureMotionInfoNV Type;
+};
+
+// Map type VkPhysicalDeviceRayTracingMotionBlurFeaturesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV> {
+    typedef VkPhysicalDeviceRayTracingMotionBlurFeaturesNV Type;
+};
+
+// Map type VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT> {
+    typedef VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceFragmentDensityMap2FeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT> {
+    typedef VkPhysicalDeviceFragmentDensityMap2FeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceFragmentDensityMap2PropertiesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceFragmentDensityMap2PropertiesEXT Type;
+};
+
+// Map type VkCopyCommandTransformInfoQCOM to id VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM
+template <>
+struct LvlTypeMap<VkCopyCommandTransformInfoQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM> {
+    typedef VkCopyCommandTransformInfoQCOM Type;
+};
+
+// Map type VkPhysicalDeviceImageCompressionControlFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceImageCompressionControlFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT> {
+    typedef VkPhysicalDeviceImageCompressionControlFeaturesEXT Type;
+};
+
+// Map type VkImageCompressionControlEXT to id VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT
+template <>
+struct LvlTypeMap<VkImageCompressionControlEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT> {
+    typedef VkImageCompressionControlEXT Type;
+};
+
+// Map type VkImageCompressionPropertiesEXT to id VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkImageCompressionPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT> {
+    typedef VkImageCompressionPropertiesEXT Type;
+};
+
+// Map type VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT> {
+    typedef VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDevice4444FormatsFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDevice4444FormatsFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT> {
+    typedef VkPhysicalDevice4444FormatsFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceFaultFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceFaultFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT> {
+    typedef VkPhysicalDeviceFaultFeaturesEXT Type;
+};
+
+// Map type VkDeviceFaultCountsEXT to id VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT
+template <>
+struct LvlTypeMap<VkDeviceFaultCountsEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT> {
+    typedef VkDeviceFaultCountsEXT Type;
+};
+
+// Map type VkDeviceFaultInfoEXT to id VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT
+template <>
+struct LvlTypeMap<VkDeviceFaultInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT> {
+    typedef VkDeviceFaultInfoEXT Type;
+};
+
+// Map type VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT> {
+    typedef VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT> {
+    typedef VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT Type;
+};
+
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+// Map type VkDirectFBSurfaceCreateInfoEXT to id VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkDirectFBSurfaceCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT> {
+    typedef VkDirectFBSurfaceCreateInfoEXT Type;
+};
+
+#endif  // VK_USE_PLATFORM_DIRECTFB_EXT
+// Map type VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT> {
+    typedef VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT Type;
+};
+
+// Map type VkMutableDescriptorTypeCreateInfoEXT to id VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkMutableDescriptorTypeCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT> {
+    typedef VkMutableDescriptorTypeCreateInfoEXT Type;
+};
+
+// Map type VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT> {
+    typedef VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT Type;
+};
+
+// Map type VkVertexInputBindingDescription2EXT to id VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT
+template <>
+struct LvlTypeMap<VkVertexInputBindingDescription2EXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT> {
+    typedef VkVertexInputBindingDescription2EXT Type;
+};
+
+// Map type VkVertexInputAttributeDescription2EXT to id VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT
+template <>
+struct LvlTypeMap<VkVertexInputAttributeDescription2EXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT> {
+    typedef VkVertexInputAttributeDescription2EXT Type;
+};
+
+// Map type VkPhysicalDeviceDrmPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDrmPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceDrmPropertiesEXT Type;
+};
+
+// Map type VkPhysicalDeviceAddressBindingReportFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceAddressBindingReportFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT> {
+    typedef VkPhysicalDeviceAddressBindingReportFeaturesEXT Type;
+};
+
+// Map type VkDeviceAddressBindingCallbackDataEXT to id VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT
+template <>
+struct LvlTypeMap<VkDeviceAddressBindingCallbackDataEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT> {
+    typedef VkDeviceAddressBindingCallbackDataEXT Type;
+};
+
+// Map type VkPhysicalDeviceDepthClipControlFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDepthClipControlFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT> {
+    typedef VkPhysicalDeviceDepthClipControlFeaturesEXT Type;
+};
+
+// Map type VkPipelineViewportDepthClipControlCreateInfoEXT to id
+// VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkPipelineViewportDepthClipControlCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT> {
+    typedef VkPipelineViewportDepthClipControlCreateInfoEXT Type;
+};
+
+// Map type VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT> {
+    typedef VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT Type;
+};
+
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkImportMemoryZirconHandleInfoFUCHSIA to id VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA
+template <>
+struct LvlTypeMap<VkImportMemoryZirconHandleInfoFUCHSIA> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA> {
+    typedef VkImportMemoryZirconHandleInfoFUCHSIA Type;
+};
+
+#endif  // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkMemoryZirconHandlePropertiesFUCHSIA to id VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA
+template <>
+struct LvlTypeMap<VkMemoryZirconHandlePropertiesFUCHSIA> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA> {
+    typedef VkMemoryZirconHandlePropertiesFUCHSIA Type;
+};
+
+#endif  // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkMemoryGetZirconHandleInfoFUCHSIA to id VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA
+template <>
+struct LvlTypeMap<VkMemoryGetZirconHandleInfoFUCHSIA> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA> {
+    typedef VkMemoryGetZirconHandleInfoFUCHSIA Type;
+};
+
+#endif  // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkImportSemaphoreZirconHandleInfoFUCHSIA to id VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA
+template <>
+struct LvlTypeMap<VkImportSemaphoreZirconHandleInfoFUCHSIA> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA> {
+    typedef VkImportSemaphoreZirconHandleInfoFUCHSIA Type;
+};
+
+#endif  // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkSemaphoreGetZirconHandleInfoFUCHSIA to id VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA
+template <>
+struct LvlTypeMap<VkSemaphoreGetZirconHandleInfoFUCHSIA> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA> {
+    typedef VkSemaphoreGetZirconHandleInfoFUCHSIA Type;
+};
+
+#endif  // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkBufferCollectionCreateInfoFUCHSIA to id VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA
+template <>
+struct LvlTypeMap<VkBufferCollectionCreateInfoFUCHSIA> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA> {
+    typedef VkBufferCollectionCreateInfoFUCHSIA Type;
+};
+
+#endif  // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkImportMemoryBufferCollectionFUCHSIA to id VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA
+template <>
+struct LvlTypeMap<VkImportMemoryBufferCollectionFUCHSIA> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA> {
+    typedef VkImportMemoryBufferCollectionFUCHSIA Type;
+};
+
+#endif  // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkBufferCollectionImageCreateInfoFUCHSIA to id VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA
+template <>
+struct LvlTypeMap<VkBufferCollectionImageCreateInfoFUCHSIA> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA> {
+    typedef VkBufferCollectionImageCreateInfoFUCHSIA Type;
+};
+
+#endif  // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkBufferCollectionConstraintsInfoFUCHSIA to id VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA
+template <>
+struct LvlTypeMap<VkBufferCollectionConstraintsInfoFUCHSIA> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA> {
+    typedef VkBufferCollectionConstraintsInfoFUCHSIA Type;
+};
+
+#endif  // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkBufferConstraintsInfoFUCHSIA to id VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA
+template <>
+struct LvlTypeMap<VkBufferConstraintsInfoFUCHSIA> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA> {
+    typedef VkBufferConstraintsInfoFUCHSIA Type;
+};
+
+#endif  // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkBufferCollectionBufferCreateInfoFUCHSIA to id VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA
+template <>
+struct LvlTypeMap<VkBufferCollectionBufferCreateInfoFUCHSIA> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA> {
+    typedef VkBufferCollectionBufferCreateInfoFUCHSIA Type;
+};
+
+#endif  // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkSysmemColorSpaceFUCHSIA to id VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA
+template <>
+struct LvlTypeMap<VkSysmemColorSpaceFUCHSIA> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA> {
+    typedef VkSysmemColorSpaceFUCHSIA Type;
+};
+
+#endif  // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkBufferCollectionPropertiesFUCHSIA to id VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA
+template <>
+struct LvlTypeMap<VkBufferCollectionPropertiesFUCHSIA> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA> {
+    typedef VkBufferCollectionPropertiesFUCHSIA Type;
+};
+
+#endif  // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkImageFormatConstraintsInfoFUCHSIA to id VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA
+template <>
+struct LvlTypeMap<VkImageFormatConstraintsInfoFUCHSIA> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA> {
+    typedef VkImageFormatConstraintsInfoFUCHSIA Type;
+};
+
+#endif  // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
+// Map type VkImageConstraintsInfoFUCHSIA to id VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA
+template <>
+struct LvlTypeMap<VkImageConstraintsInfoFUCHSIA> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA> {
+    typedef VkImageConstraintsInfoFUCHSIA Type;
+};
+
+#endif  // VK_USE_PLATFORM_FUCHSIA
+// Map type VkSubpassShadingPipelineCreateInfoHUAWEI to id VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI
+template <>
+struct LvlTypeMap<VkSubpassShadingPipelineCreateInfoHUAWEI> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI> {
+    typedef VkSubpassShadingPipelineCreateInfoHUAWEI Type;
+};
+
+// Map type VkPhysicalDeviceSubpassShadingFeaturesHUAWEI to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI
+template <>
+struct LvlTypeMap<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI> {
+    typedef VkPhysicalDeviceSubpassShadingFeaturesHUAWEI Type;
+};
+
+// Map type VkPhysicalDeviceSubpassShadingPropertiesHUAWEI to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI
+template <>
+struct LvlTypeMap<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI> {
+    typedef VkPhysicalDeviceSubpassShadingPropertiesHUAWEI Type;
+};
+
+// Map type VkPhysicalDeviceInvocationMaskFeaturesHUAWEI to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI
+template <>
+struct LvlTypeMap<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI> {
+    typedef VkPhysicalDeviceInvocationMaskFeaturesHUAWEI Type;
+};
+
+// Map type VkMemoryGetRemoteAddressInfoNV to id VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV
+template <>
+struct LvlTypeMap<VkMemoryGetRemoteAddressInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV> {
+    typedef VkMemoryGetRemoteAddressInfoNV Type;
+};
+
+// Map type VkPhysicalDeviceExternalMemoryRDMAFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV> {
+    typedef VkPhysicalDeviceExternalMemoryRDMAFeaturesNV Type;
+};
+
+// Map type VkPipelinePropertiesIdentifierEXT to id VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT
+template <>
+struct LvlTypeMap<VkPipelinePropertiesIdentifierEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT> {
+    typedef VkPipelinePropertiesIdentifierEXT Type;
+};
+
+// Map type VkPhysicalDevicePipelinePropertiesFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDevicePipelinePropertiesFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT> {
+    typedef VkPhysicalDevicePipelinePropertiesFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceFrameBoundaryFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceFrameBoundaryFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT> {
+    typedef VkPhysicalDeviceFrameBoundaryFeaturesEXT Type;
+};
+
+// Map type VkFrameBoundaryEXT to id VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT
+template <>
+struct LvlTypeMap<VkFrameBoundaryEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT> {
+    typedef VkFrameBoundaryEXT Type;
+};
+
+// Map type VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT> {
+    typedef VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT Type;
+};
+
+// Map type VkSubpassResolvePerformanceQueryEXT to id VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT
+template <>
+struct LvlTypeMap<VkSubpassResolvePerformanceQueryEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT> {
+    typedef VkSubpassResolvePerformanceQueryEXT Type;
+};
+
+// Map type VkMultisampledRenderToSingleSampledInfoEXT to id VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT
+template <>
+struct LvlTypeMap<VkMultisampledRenderToSingleSampledInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT> {
+    typedef VkMultisampledRenderToSingleSampledInfoEXT Type;
+};
+
+// Map type VkPhysicalDeviceExtendedDynamicState2FeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT> {
+    typedef VkPhysicalDeviceExtendedDynamicState2FeaturesEXT Type;
+};
+
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+// Map type VkScreenSurfaceCreateInfoQNX to id VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX
+template <>
+struct LvlTypeMap<VkScreenSurfaceCreateInfoQNX> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX> {
+    typedef VkScreenSurfaceCreateInfoQNX Type;
+};
+
+#endif  // VK_USE_PLATFORM_SCREEN_QNX
+// Map type VkPhysicalDeviceColorWriteEnableFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceColorWriteEnableFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT> {
+    typedef VkPhysicalDeviceColorWriteEnableFeaturesEXT Type;
+};
+
+// Map type VkPipelineColorWriteCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkPipelineColorWriteCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT> {
+    typedef VkPipelineColorWriteCreateInfoEXT Type;
+};
+
+// Map type VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT> {
+    typedef VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE
+template <>
+struct LvlTypeMap<VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE> {
+    typedef VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE Type;
+};
+
+// Map type VkVideoEncodeRgbConversionCapabilitiesVALVE to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE
+template <>
+struct LvlTypeMap<VkVideoEncodeRgbConversionCapabilitiesVALVE> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE> {
+    typedef VkVideoEncodeRgbConversionCapabilitiesVALVE Type;
+};
+
+// Map type VkVideoEncodeProfileRgbConversionInfoVALVE to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE
+template <>
+struct LvlTypeMap<VkVideoEncodeProfileRgbConversionInfoVALVE> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE> {
+    typedef VkVideoEncodeProfileRgbConversionInfoVALVE Type;
+};
+
+// Map type VkVideoEncodeSessionRgbConversionCreateInfoVALVE to id
+// VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE
+template <>
+struct LvlTypeMap<VkVideoEncodeSessionRgbConversionCreateInfoVALVE> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE> {
+    typedef VkVideoEncodeSessionRgbConversionCreateInfoVALVE Type;
+};
+
+// Map type VkPhysicalDeviceImageViewMinLodFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceImageViewMinLodFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT> {
+    typedef VkPhysicalDeviceImageViewMinLodFeaturesEXT Type;
+};
+
+// Map type VkImageViewMinLodCreateInfoEXT to id VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkImageViewMinLodCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT> {
+    typedef VkImageViewMinLodCreateInfoEXT Type;
+};
+
+// Map type VkPhysicalDeviceMultiDrawFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMultiDrawFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT> {
+    typedef VkPhysicalDeviceMultiDrawFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceMultiDrawPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMultiDrawPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceMultiDrawPropertiesEXT Type;
+};
+
+// Map type VkPhysicalDeviceImage2DViewOf3DFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT> {
+    typedef VkPhysicalDeviceImage2DViewOf3DFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceShaderTileImageFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderTileImageFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT> {
+    typedef VkPhysicalDeviceShaderTileImageFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceShaderTileImagePropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderTileImagePropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceShaderTileImagePropertiesEXT Type;
+};
+
+// Map type VkMicromapBuildInfoEXT to id VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT
+template <>
+struct LvlTypeMap<VkMicromapBuildInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT> {
+    typedef VkMicromapBuildInfoEXT Type;
+};
+
+// Map type VkMicromapCreateInfoEXT to id VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkMicromapCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT> {
+    typedef VkMicromapCreateInfoEXT Type;
+};
+
+// Map type VkPhysicalDeviceOpacityMicromapFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceOpacityMicromapFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT> {
+    typedef VkPhysicalDeviceOpacityMicromapFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceOpacityMicromapPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceOpacityMicromapPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceOpacityMicromapPropertiesEXT Type;
+};
+
+// Map type VkMicromapVersionInfoEXT to id VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT
+template <>
+struct LvlTypeMap<VkMicromapVersionInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT> {
+    typedef VkMicromapVersionInfoEXT Type;
+};
+
+// Map type VkCopyMicromapToMemoryInfoEXT to id VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT
+template <>
+struct LvlTypeMap<VkCopyMicromapToMemoryInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT> {
+    typedef VkCopyMicromapToMemoryInfoEXT Type;
+};
+
+// Map type VkCopyMemoryToMicromapInfoEXT to id VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT
+template <>
+struct LvlTypeMap<VkCopyMemoryToMicromapInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT> {
+    typedef VkCopyMemoryToMicromapInfoEXT Type;
+};
+
+// Map type VkCopyMicromapInfoEXT to id VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT
+template <>
+struct LvlTypeMap<VkCopyMicromapInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT> {
+    typedef VkCopyMicromapInfoEXT Type;
+};
+
+// Map type VkMicromapBuildSizesInfoEXT to id VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT
+template <>
+struct LvlTypeMap<VkMicromapBuildSizesInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT> {
+    typedef VkMicromapBuildSizesInfoEXT Type;
+};
+
+// Map type VkAccelerationStructureTrianglesOpacityMicromapEXT to id
+// VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT
+template <>
+struct LvlTypeMap<VkAccelerationStructureTrianglesOpacityMicromapEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT> {
+    typedef VkAccelerationStructureTrianglesOpacityMicromapEXT Type;
+};
+
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+// Map type VkPhysicalDeviceDisplacementMicromapFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDisplacementMicromapFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV> {
+    typedef VkPhysicalDeviceDisplacementMicromapFeaturesNV Type;
+};
+
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+// Map type VkPhysicalDeviceDisplacementMicromapPropertiesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDisplacementMicromapPropertiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV> {
+    typedef VkPhysicalDeviceDisplacementMicromapPropertiesNV Type;
+};
+
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+// Map type VkAccelerationStructureTrianglesDisplacementMicromapNV to id
+// VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV
+template <>
+struct LvlTypeMap<VkAccelerationStructureTrianglesDisplacementMicromapNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV> {
+    typedef VkAccelerationStructureTrianglesDisplacementMicromapNV Type;
+};
+
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+// Map type VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI
+template <>
+struct LvlTypeMap<VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI> {
+    typedef VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI Type;
+};
+
+// Map type VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI
+template <>
+struct LvlTypeMap<VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI> {
+    typedef VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI Type;
+};
+
+// Map type VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI
+template <>
+struct LvlTypeMap<VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI> {
+    typedef VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI Type;
+};
+
+// Map type VkPhysicalDeviceBorderColorSwizzleFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT> {
+    typedef VkPhysicalDeviceBorderColorSwizzleFeaturesEXT Type;
+};
+
+// Map type VkSamplerBorderColorComponentMappingCreateInfoEXT to id
+// VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkSamplerBorderColorComponentMappingCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT> {
+    typedef VkSamplerBorderColorComponentMappingCreateInfoEXT Type;
+};
+
+// Map type VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT> {
+    typedef VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceShaderCorePropertiesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderCorePropertiesARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM> {
+    typedef VkPhysicalDeviceShaderCorePropertiesARM Type;
+};
+
+// Map type VkDeviceQueueShaderCoreControlCreateInfoARM to id VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM
+template <>
+struct LvlTypeMap<VkDeviceQueueShaderCoreControlCreateInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM> {
+    typedef VkDeviceQueueShaderCoreControlCreateInfoARM Type;
+};
+
+// Map type VkPhysicalDeviceSchedulingControlsFeaturesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceSchedulingControlsFeaturesARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM> {
+    typedef VkPhysicalDeviceSchedulingControlsFeaturesARM Type;
+};
+
+// Map type VkPhysicalDeviceSchedulingControlsPropertiesARM to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceSchedulingControlsPropertiesARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM> {
+    typedef VkPhysicalDeviceSchedulingControlsPropertiesARM Type;
+};
+
+// Map type VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT> {
+    typedef VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT Type;
+};
+
+// Map type VkImageViewSlicedCreateInfoEXT to id VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkImageViewSlicedCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT> {
+    typedef VkImageViewSlicedCreateInfoEXT Type;
+};
+
+// Map type VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE> {
+    typedef VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE Type;
+};
+
+// Map type VkDescriptorSetBindingReferenceVALVE to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE
+template <>
+struct LvlTypeMap<VkDescriptorSetBindingReferenceVALVE> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE> {
+    typedef VkDescriptorSetBindingReferenceVALVE Type;
+};
+
+// Map type VkDescriptorSetLayoutHostMappingInfoVALVE to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE
+template <>
+struct LvlTypeMap<VkDescriptorSetLayoutHostMappingInfoVALVE> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE> {
+    typedef VkDescriptorSetLayoutHostMappingInfoVALVE Type;
+};
+
+// Map type VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT> {
+    typedef VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceRenderPassStripedFeaturesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceRenderPassStripedFeaturesARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM> {
+    typedef VkPhysicalDeviceRenderPassStripedFeaturesARM Type;
+};
+
+// Map type VkPhysicalDeviceRenderPassStripedPropertiesARM to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceRenderPassStripedPropertiesARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM> {
+    typedef VkPhysicalDeviceRenderPassStripedPropertiesARM Type;
+};
+
+// Map type VkRenderPassStripeInfoARM to id VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM
+template <>
+struct LvlTypeMap<VkRenderPassStripeInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM> {
+    typedef VkRenderPassStripeInfoARM Type;
+};
+
+// Map type VkRenderPassStripeBeginInfoARM to id VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM
+template <>
+struct LvlTypeMap<VkRenderPassStripeBeginInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM> {
+    typedef VkRenderPassStripeBeginInfoARM Type;
+};
+
+// Map type VkRenderPassStripeSubmitInfoARM to id VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM
+template <>
+struct LvlTypeMap<VkRenderPassStripeSubmitInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM> {
+    typedef VkRenderPassStripeSubmitInfoARM Type;
+};
+
+// Map type VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT> {
+    typedef VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT Type;
+};
+
+// Map type VkRenderPassFragmentDensityMapOffsetEndInfoEXT to id
+// VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT
+template <>
+struct LvlTypeMap<VkRenderPassFragmentDensityMapOffsetEndInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT> {
+    typedef VkRenderPassFragmentDensityMapOffsetEndInfoEXT Type;
+};
+
+// Map type VkPhysicalDeviceCopyMemoryIndirectFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceCopyMemoryIndirectFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV> {
+    typedef VkPhysicalDeviceCopyMemoryIndirectFeaturesNV Type;
+};
+
+// Map type VkPhysicalDeviceMemoryDecompressionFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMemoryDecompressionFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT> {
+    typedef VkPhysicalDeviceMemoryDecompressionFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceMemoryDecompressionPropertiesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMemoryDecompressionPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceMemoryDecompressionPropertiesEXT Type;
+};
+
+// Map type VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV> {
+    typedef VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV Type;
+};
+
+// Map type VkComputePipelineIndirectBufferInfoNV to id VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV
+template <>
+struct LvlTypeMap<VkComputePipelineIndirectBufferInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV> {
+    typedef VkComputePipelineIndirectBufferInfoNV Type;
+};
+
+// Map type VkPipelineIndirectDeviceAddressInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV
+template <>
+struct LvlTypeMap<VkPipelineIndirectDeviceAddressInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV> {
+    typedef VkPipelineIndirectDeviceAddressInfoNV Type;
+};
+
+// Map type VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV> {
+    typedef VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV Type;
+};
+
+// Map type VkAccelerationStructureGeometryLinearSweptSpheresDataNV to id
+// VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV
+template <>
+struct LvlTypeMap<VkAccelerationStructureGeometryLinearSweptSpheresDataNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV> {
+    typedef VkAccelerationStructureGeometryLinearSweptSpheresDataNV Type;
+};
+
+// Map type VkAccelerationStructureGeometrySpheresDataNV to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV
+template <>
+struct LvlTypeMap<VkAccelerationStructureGeometrySpheresDataNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV> {
+    typedef VkAccelerationStructureGeometrySpheresDataNV Type;
+};
+
+// Map type VkPhysicalDeviceLinearColorAttachmentFeaturesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceLinearColorAttachmentFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV> {
+    typedef VkPhysicalDeviceLinearColorAttachmentFeaturesNV Type;
+};
+
+// Map type VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT> {
+    typedef VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT Type;
+};
+
+// Map type VkImageViewSampleWeightCreateInfoQCOM to id VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM
+template <>
+struct LvlTypeMap<VkImageViewSampleWeightCreateInfoQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM> {
+    typedef VkImageViewSampleWeightCreateInfoQCOM Type;
+};
+
+// Map type VkPhysicalDeviceImageProcessingFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceImageProcessingFeaturesQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM> {
+    typedef VkPhysicalDeviceImageProcessingFeaturesQCOM Type;
+};
+
+// Map type VkPhysicalDeviceImageProcessingPropertiesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceImageProcessingPropertiesQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM> {
+    typedef VkPhysicalDeviceImageProcessingPropertiesQCOM Type;
+};
+
+// Map type VkPhysicalDeviceNestedCommandBufferFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceNestedCommandBufferFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT> {
+    typedef VkPhysicalDeviceNestedCommandBufferFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceNestedCommandBufferPropertiesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceNestedCommandBufferPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceNestedCommandBufferPropertiesEXT Type;
+};
+
+#ifdef VK_USE_PLATFORM_OHOS
+// Map type VkNativeBufferUsageOHOS to id VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS
+template <>
+struct LvlTypeMap<VkNativeBufferUsageOHOS> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS> {
+    typedef VkNativeBufferUsageOHOS Type;
+};
+
+#endif  // VK_USE_PLATFORM_OHOS
+#ifdef VK_USE_PLATFORM_OHOS
+// Map type VkNativeBufferPropertiesOHOS to id VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS
+template <>
+struct LvlTypeMap<VkNativeBufferPropertiesOHOS> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS> {
+    typedef VkNativeBufferPropertiesOHOS Type;
+};
+
+#endif  // VK_USE_PLATFORM_OHOS
+#ifdef VK_USE_PLATFORM_OHOS
+// Map type VkNativeBufferFormatPropertiesOHOS to id VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS
+template <>
+struct LvlTypeMap<VkNativeBufferFormatPropertiesOHOS> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS> {
+    typedef VkNativeBufferFormatPropertiesOHOS Type;
+};
+
+#endif  // VK_USE_PLATFORM_OHOS
+#ifdef VK_USE_PLATFORM_OHOS
+// Map type VkImportNativeBufferInfoOHOS to id VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS
+template <>
+struct LvlTypeMap<VkImportNativeBufferInfoOHOS> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS> {
+    typedef VkImportNativeBufferInfoOHOS Type;
+};
+
+#endif  // VK_USE_PLATFORM_OHOS
+#ifdef VK_USE_PLATFORM_OHOS
+// Map type VkMemoryGetNativeBufferInfoOHOS to id VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS
+template <>
+struct LvlTypeMap<VkMemoryGetNativeBufferInfoOHOS> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS> {
+    typedef VkMemoryGetNativeBufferInfoOHOS Type;
+};
+
+#endif  // VK_USE_PLATFORM_OHOS
+#ifdef VK_USE_PLATFORM_OHOS
+// Map type VkExternalFormatOHOS to id VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS
+template <>
+struct LvlTypeMap<VkExternalFormatOHOS> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS> {
+    typedef VkExternalFormatOHOS Type;
+};
+
+#endif  // VK_USE_PLATFORM_OHOS
+// Map type VkExternalMemoryAcquireUnmodifiedEXT to id VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT
+template <>
+struct LvlTypeMap<VkExternalMemoryAcquireUnmodifiedEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT> {
+    typedef VkExternalMemoryAcquireUnmodifiedEXT Type;
+};
+
+// Map type VkPhysicalDeviceExtendedDynamicState3FeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT> {
+    typedef VkPhysicalDeviceExtendedDynamicState3FeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceExtendedDynamicState3PropertiesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceExtendedDynamicState3PropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceExtendedDynamicState3PropertiesEXT Type;
+};
+
+// Map type VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT> {
+    typedef VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT Type;
+};
+
+// Map type VkRenderPassCreationControlEXT to id VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT
+template <>
+struct LvlTypeMap<VkRenderPassCreationControlEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT> {
+    typedef VkRenderPassCreationControlEXT Type;
+};
+
+// Map type VkRenderPassCreationFeedbackCreateInfoEXT to id VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkRenderPassCreationFeedbackCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT> {
+    typedef VkRenderPassCreationFeedbackCreateInfoEXT Type;
+};
+
+// Map type VkRenderPassSubpassFeedbackCreateInfoEXT to id VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkRenderPassSubpassFeedbackCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT> {
+    typedef VkRenderPassSubpassFeedbackCreateInfoEXT Type;
+};
+
+// Map type VkDirectDriverLoadingInfoLUNARG to id VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG
+template <>
+struct LvlTypeMap<VkDirectDriverLoadingInfoLUNARG> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG> {
+    typedef VkDirectDriverLoadingInfoLUNARG Type;
+};
+
+// Map type VkDirectDriverLoadingListLUNARG to id VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG
+template <>
+struct LvlTypeMap<VkDirectDriverLoadingListLUNARG> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG> {
+    typedef VkDirectDriverLoadingListLUNARG Type;
+};
+
+// Map type VkTensorDescriptionARM to id VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM
+template <>
+struct LvlTypeMap<VkTensorDescriptionARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM> {
+    typedef VkTensorDescriptionARM Type;
+};
+
+// Map type VkTensorCreateInfoARM to id VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM
+template <>
+struct LvlTypeMap<VkTensorCreateInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM> {
+    typedef VkTensorCreateInfoARM Type;
+};
+
+// Map type VkTensorMemoryRequirementsInfoARM to id VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM
+template <>
+struct LvlTypeMap<VkTensorMemoryRequirementsInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM> {
+    typedef VkTensorMemoryRequirementsInfoARM Type;
+};
+
+// Map type VkBindTensorMemoryInfoARM to id VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM
+template <>
+struct LvlTypeMap<VkBindTensorMemoryInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM> {
+    typedef VkBindTensorMemoryInfoARM Type;
+};
+
+// Map type VkWriteDescriptorSetTensorARM to id VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM
+template <>
+struct LvlTypeMap<VkWriteDescriptorSetTensorARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM> {
+    typedef VkWriteDescriptorSetTensorARM Type;
+};
+
+// Map type VkTensorFormatPropertiesARM to id VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM
+template <>
+struct LvlTypeMap<VkTensorFormatPropertiesARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM> {
+    typedef VkTensorFormatPropertiesARM Type;
+};
+
+// Map type VkPhysicalDeviceTensorPropertiesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceTensorPropertiesARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM> {
+    typedef VkPhysicalDeviceTensorPropertiesARM Type;
+};
+
+// Map type VkTensorMemoryBarrierARM to id VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM
+template <>
+struct LvlTypeMap<VkTensorMemoryBarrierARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM> {
+    typedef VkTensorMemoryBarrierARM Type;
+};
+
+// Map type VkTensorDependencyInfoARM to id VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM
+template <>
+struct LvlTypeMap<VkTensorDependencyInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM> {
+    typedef VkTensorDependencyInfoARM Type;
+};
+
+// Map type VkPhysicalDeviceTensorFeaturesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceTensorFeaturesARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM> {
+    typedef VkPhysicalDeviceTensorFeaturesARM Type;
+};
+
+// Map type VkDeviceTensorMemoryRequirementsARM to id VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM
+template <>
+struct LvlTypeMap<VkDeviceTensorMemoryRequirementsARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM> {
+    typedef VkDeviceTensorMemoryRequirementsARM Type;
+};
+
+// Map type VkTensorCopyARM to id VK_STRUCTURE_TYPE_TENSOR_COPY_ARM
+template <>
+struct LvlTypeMap<VkTensorCopyARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_TENSOR_COPY_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_TENSOR_COPY_ARM> {
+    typedef VkTensorCopyARM Type;
+};
+
+// Map type VkCopyTensorInfoARM to id VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM
+template <>
+struct LvlTypeMap<VkCopyTensorInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM> {
+    typedef VkCopyTensorInfoARM Type;
+};
+
+// Map type VkMemoryDedicatedAllocateInfoTensorARM to id VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM
+template <>
+struct LvlTypeMap<VkMemoryDedicatedAllocateInfoTensorARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM> {
+    typedef VkMemoryDedicatedAllocateInfoTensorARM Type;
+};
+
+// Map type VkPhysicalDeviceExternalTensorInfoARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceExternalTensorInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM> {
+    typedef VkPhysicalDeviceExternalTensorInfoARM Type;
+};
+
+// Map type VkExternalTensorPropertiesARM to id VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM
+template <>
+struct LvlTypeMap<VkExternalTensorPropertiesARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM> {
+    typedef VkExternalTensorPropertiesARM Type;
+};
+
+// Map type VkExternalMemoryTensorCreateInfoARM to id VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM
+template <>
+struct LvlTypeMap<VkExternalMemoryTensorCreateInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM> {
+    typedef VkExternalMemoryTensorCreateInfoARM Type;
+};
+
+// Map type VkPhysicalDeviceDescriptorBufferTensorFeaturesARM to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDescriptorBufferTensorFeaturesARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM> {
+    typedef VkPhysicalDeviceDescriptorBufferTensorFeaturesARM Type;
+};
+
+// Map type VkPhysicalDeviceDescriptorBufferTensorPropertiesARM to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDescriptorBufferTensorPropertiesARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM> {
+    typedef VkPhysicalDeviceDescriptorBufferTensorPropertiesARM Type;
+};
+
+// Map type VkDescriptorGetTensorInfoARM to id VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM
+template <>
+struct LvlTypeMap<VkDescriptorGetTensorInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM> {
+    typedef VkDescriptorGetTensorInfoARM Type;
+};
+
+// Map type VkTensorCaptureDescriptorDataInfoARM to id VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM
+template <>
+struct LvlTypeMap<VkTensorCaptureDescriptorDataInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM> {
+    typedef VkTensorCaptureDescriptorDataInfoARM Type;
+};
+
+// Map type VkTensorViewCaptureDescriptorDataInfoARM to id VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM
+template <>
+struct LvlTypeMap<VkTensorViewCaptureDescriptorDataInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM> {
+    typedef VkTensorViewCaptureDescriptorDataInfoARM Type;
+};
+
+// Map type VkFrameBoundaryTensorsARM to id VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM
+template <>
+struct LvlTypeMap<VkFrameBoundaryTensorsARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM> {
+    typedef VkFrameBoundaryTensorsARM Type;
+};
+
+// Map type VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT> {
+    typedef VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT Type;
+};
+
+// Map type VkPipelineShaderStageModuleIdentifierCreateInfoEXT to id
+// VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkPipelineShaderStageModuleIdentifierCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT> {
+    typedef VkPipelineShaderStageModuleIdentifierCreateInfoEXT Type;
+};
+
+// Map type VkShaderModuleIdentifierEXT to id VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT
+template <>
+struct LvlTypeMap<VkShaderModuleIdentifierEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT> {
+    typedef VkShaderModuleIdentifierEXT Type;
+};
+
+// Map type VkPhysicalDeviceOpticalFlowFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceOpticalFlowFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV> {
+    typedef VkPhysicalDeviceOpticalFlowFeaturesNV Type;
+};
+
+// Map type VkPhysicalDeviceOpticalFlowPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceOpticalFlowPropertiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV> {
+    typedef VkPhysicalDeviceOpticalFlowPropertiesNV Type;
+};
+
+// Map type VkOpticalFlowImageFormatInfoNV to id VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV
+template <>
+struct LvlTypeMap<VkOpticalFlowImageFormatInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV> {
+    typedef VkOpticalFlowImageFormatInfoNV Type;
+};
+
+// Map type VkOpticalFlowImageFormatPropertiesNV to id VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV
+template <>
+struct LvlTypeMap<VkOpticalFlowImageFormatPropertiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV> {
+    typedef VkOpticalFlowImageFormatPropertiesNV Type;
+};
+
+// Map type VkOpticalFlowSessionCreateInfoNV to id VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkOpticalFlowSessionCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV> {
+    typedef VkOpticalFlowSessionCreateInfoNV Type;
+};
+
+// Map type VkOpticalFlowSessionCreatePrivateDataInfoNV to id VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV
+template <>
+struct LvlTypeMap<VkOpticalFlowSessionCreatePrivateDataInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV> {
+    typedef VkOpticalFlowSessionCreatePrivateDataInfoNV Type;
+};
+
+// Map type VkOpticalFlowExecuteInfoNV to id VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV
+template <>
+struct LvlTypeMap<VkOpticalFlowExecuteInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV> {
+    typedef VkOpticalFlowExecuteInfoNV Type;
+};
+
+// Map type VkPhysicalDeviceLegacyDitheringFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceLegacyDitheringFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT> {
+    typedef VkPhysicalDeviceLegacyDitheringFeaturesEXT Type;
+};
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+// Map type VkPhysicalDeviceExternalFormatResolveFeaturesANDROID to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID
+template <>
+struct LvlTypeMap<VkPhysicalDeviceExternalFormatResolveFeaturesANDROID> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID> {
+    typedef VkPhysicalDeviceExternalFormatResolveFeaturesANDROID Type;
+};
+
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+// Map type VkPhysicalDeviceExternalFormatResolvePropertiesANDROID to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID
+template <>
+struct LvlTypeMap<VkPhysicalDeviceExternalFormatResolvePropertiesANDROID> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID> {
+    typedef VkPhysicalDeviceExternalFormatResolvePropertiesANDROID Type;
+};
+
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+// Map type VkAndroidHardwareBufferFormatResolvePropertiesANDROID to id
+// VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID
+template <>
+struct LvlTypeMap<VkAndroidHardwareBufferFormatResolvePropertiesANDROID> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID> {
+    typedef VkAndroidHardwareBufferFormatResolvePropertiesANDROID Type;
+};
+
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+// Map type VkPhysicalDeviceAntiLagFeaturesAMD to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD
+template <>
+struct LvlTypeMap<VkPhysicalDeviceAntiLagFeaturesAMD> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD> {
+    typedef VkPhysicalDeviceAntiLagFeaturesAMD Type;
+};
+
+// Map type VkAntiLagPresentationInfoAMD to id VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD
+template <>
+struct LvlTypeMap<VkAntiLagPresentationInfoAMD> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD> {
+    typedef VkAntiLagPresentationInfoAMD Type;
+};
+
+// Map type VkAntiLagDataAMD to id VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD
+template <>
+struct LvlTypeMap<VkAntiLagDataAMD> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD> {
+    typedef VkAntiLagDataAMD Type;
+};
+
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+// Map type VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX> {
+    typedef VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX Type;
+};
+
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+// Map type VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX to id
+// VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX
+template <>
+struct LvlTypeMap<VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX> {
+    typedef VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX Type;
+};
+
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+// Map type VkPhysicalDeviceShaderObjectFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderObjectFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT> {
+    typedef VkPhysicalDeviceShaderObjectFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceShaderObjectPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderObjectPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceShaderObjectPropertiesEXT Type;
+};
+
+// Map type VkShaderCreateInfoEXT to id VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkShaderCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT> {
+    typedef VkShaderCreateInfoEXT Type;
+};
+
+// Map type VkPhysicalDeviceTilePropertiesFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceTilePropertiesFeaturesQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM> {
+    typedef VkPhysicalDeviceTilePropertiesFeaturesQCOM Type;
+};
+
+// Map type VkTilePropertiesQCOM to id VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM
+template <>
+struct LvlTypeMap<VkTilePropertiesQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM> {
+    typedef VkTilePropertiesQCOM Type;
+};
+
+// Map type VkPhysicalDeviceAmigoProfilingFeaturesSEC to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC
+template <>
+struct LvlTypeMap<VkPhysicalDeviceAmigoProfilingFeaturesSEC> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC> {
+    typedef VkPhysicalDeviceAmigoProfilingFeaturesSEC Type;
+};
+
+// Map type VkAmigoProfilingSubmitInfoSEC to id VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC
+template <>
+struct LvlTypeMap<VkAmigoProfilingSubmitInfoSEC> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC> {
+    typedef VkAmigoProfilingSubmitInfoSEC Type;
+};
+
+// Map type VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM> {
+    typedef VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM Type;
+};
+
+// Map type VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV> {
+    typedef VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV Type;
+};
+
+// Map type VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV> {
+    typedef VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV Type;
+};
+
+// Map type VkPhysicalDeviceCooperativeVectorPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceCooperativeVectorPropertiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV> {
+    typedef VkPhysicalDeviceCooperativeVectorPropertiesNV Type;
+};
+
+// Map type VkPhysicalDeviceCooperativeVectorFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceCooperativeVectorFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV> {
+    typedef VkPhysicalDeviceCooperativeVectorFeaturesNV Type;
+};
+
+// Map type VkCooperativeVectorPropertiesNV to id VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV
+template <>
+struct LvlTypeMap<VkCooperativeVectorPropertiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV> {
+    typedef VkCooperativeVectorPropertiesNV Type;
+};
+
+// Map type VkConvertCooperativeVectorMatrixInfoNV to id VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV
+template <>
+struct LvlTypeMap<VkConvertCooperativeVectorMatrixInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV> {
+    typedef VkConvertCooperativeVectorMatrixInfoNV Type;
+};
+
+// Map type VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV> {
+    typedef VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV Type;
+};
+
+// Map type VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV> {
+    typedef VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV Type;
+};
+
+// Map type VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT> {
+    typedef VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT Type;
+};
+
+// Map type VkLayerSettingsCreateInfoEXT to id VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkLayerSettingsCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT> {
+    typedef VkLayerSettingsCreateInfoEXT Type;
+};
+
+// Map type VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM> {
+    typedef VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM Type;
+};
+
+// Map type VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM> {
+    typedef VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM Type;
+};
+
+// Map type VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT> {
+    typedef VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT> {
+    typedef VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT Type;
+};
+
+// Map type VkLatencySleepModeInfoNV to id VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV
+template <>
+struct LvlTypeMap<VkLatencySleepModeInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV> {
+    typedef VkLatencySleepModeInfoNV Type;
+};
+
+// Map type VkLatencySleepInfoNV to id VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV
+template <>
+struct LvlTypeMap<VkLatencySleepInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV> {
+    typedef VkLatencySleepInfoNV Type;
+};
+
+// Map type VkSetLatencyMarkerInfoNV to id VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV
+template <>
+struct LvlTypeMap<VkSetLatencyMarkerInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV> {
+    typedef VkSetLatencyMarkerInfoNV Type;
+};
+
+// Map type VkLatencyTimingsFrameReportNV to id VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV
+template <>
+struct LvlTypeMap<VkLatencyTimingsFrameReportNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV> {
+    typedef VkLatencyTimingsFrameReportNV Type;
+};
+
+// Map type VkGetLatencyMarkerInfoNV to id VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV
+template <>
+struct LvlTypeMap<VkGetLatencyMarkerInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV> {
+    typedef VkGetLatencyMarkerInfoNV Type;
+};
+
+// Map type VkLatencySubmissionPresentIdNV to id VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV
+template <>
+struct LvlTypeMap<VkLatencySubmissionPresentIdNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV> {
+    typedef VkLatencySubmissionPresentIdNV Type;
+};
+
+// Map type VkSwapchainLatencyCreateInfoNV to id VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkSwapchainLatencyCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV> {
+    typedef VkSwapchainLatencyCreateInfoNV Type;
+};
+
+// Map type VkOutOfBandQueueTypeInfoNV to id VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV
+template <>
+struct LvlTypeMap<VkOutOfBandQueueTypeInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV> {
+    typedef VkOutOfBandQueueTypeInfoNV Type;
+};
+
+// Map type VkLatencySurfaceCapabilitiesNV to id VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV
+template <>
+struct LvlTypeMap<VkLatencySurfaceCapabilitiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV> {
+    typedef VkLatencySurfaceCapabilitiesNV Type;
+};
+
+// Map type VkPhysicalDeviceDataGraphFeaturesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDataGraphFeaturesARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM> {
+    typedef VkPhysicalDeviceDataGraphFeaturesARM Type;
+};
+
+// Map type VkDataGraphPipelineConstantARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM
+template <>
+struct LvlTypeMap<VkDataGraphPipelineConstantARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM> {
+    typedef VkDataGraphPipelineConstantARM Type;
+};
+
+// Map type VkDataGraphPipelineResourceInfoARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM
+template <>
+struct LvlTypeMap<VkDataGraphPipelineResourceInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM> {
+    typedef VkDataGraphPipelineResourceInfoARM Type;
+};
+
+// Map type VkDataGraphPipelineCompilerControlCreateInfoARM to id
+// VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM
+template <>
+struct LvlTypeMap<VkDataGraphPipelineCompilerControlCreateInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM> {
+    typedef VkDataGraphPipelineCompilerControlCreateInfoARM Type;
+};
+
+// Map type VkDataGraphPipelineCreateInfoARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM
+template <>
+struct LvlTypeMap<VkDataGraphPipelineCreateInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM> {
+    typedef VkDataGraphPipelineCreateInfoARM Type;
+};
+
+// Map type VkDataGraphPipelineShaderModuleCreateInfoARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM
+template <>
+struct LvlTypeMap<VkDataGraphPipelineShaderModuleCreateInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM> {
+    typedef VkDataGraphPipelineShaderModuleCreateInfoARM Type;
+};
+
+// Map type VkDataGraphPipelineSessionCreateInfoARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM
+template <>
+struct LvlTypeMap<VkDataGraphPipelineSessionCreateInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM> {
+    typedef VkDataGraphPipelineSessionCreateInfoARM Type;
+};
+
+// Map type VkDataGraphPipelineSessionBindPointRequirementsInfoARM to id
+// VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM
+template <>
+struct LvlTypeMap<VkDataGraphPipelineSessionBindPointRequirementsInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM> {
+    typedef VkDataGraphPipelineSessionBindPointRequirementsInfoARM Type;
+};
+
+// Map type VkDataGraphPipelineSessionBindPointRequirementARM to id
+// VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM
+template <>
+struct LvlTypeMap<VkDataGraphPipelineSessionBindPointRequirementARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM> {
+    typedef VkDataGraphPipelineSessionBindPointRequirementARM Type;
+};
+
+// Map type VkDataGraphPipelineSessionMemoryRequirementsInfoARM to id
+// VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM
+template <>
+struct LvlTypeMap<VkDataGraphPipelineSessionMemoryRequirementsInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM> {
+    typedef VkDataGraphPipelineSessionMemoryRequirementsInfoARM Type;
+};
+
+// Map type VkBindDataGraphPipelineSessionMemoryInfoARM to id VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM
+template <>
+struct LvlTypeMap<VkBindDataGraphPipelineSessionMemoryInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM> {
+    typedef VkBindDataGraphPipelineSessionMemoryInfoARM Type;
+};
+
+// Map type VkDataGraphPipelineInfoARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM
+template <>
+struct LvlTypeMap<VkDataGraphPipelineInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM> {
+    typedef VkDataGraphPipelineInfoARM Type;
+};
+
+// Map type VkDataGraphPipelinePropertyQueryResultARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM
+template <>
+struct LvlTypeMap<VkDataGraphPipelinePropertyQueryResultARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM> {
+    typedef VkDataGraphPipelinePropertyQueryResultARM Type;
+};
+
+// Map type VkDataGraphPipelineIdentifierCreateInfoARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM
+template <>
+struct LvlTypeMap<VkDataGraphPipelineIdentifierCreateInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM> {
+    typedef VkDataGraphPipelineIdentifierCreateInfoARM Type;
+};
+
+// Map type VkDataGraphPipelineDispatchInfoARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM
+template <>
+struct LvlTypeMap<VkDataGraphPipelineDispatchInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM> {
+    typedef VkDataGraphPipelineDispatchInfoARM Type;
+};
+
+// Map type VkQueueFamilyDataGraphPropertiesARM to id VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM
+template <>
+struct LvlTypeMap<VkQueueFamilyDataGraphPropertiesARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM> {
+    typedef VkQueueFamilyDataGraphPropertiesARM Type;
+};
+
+// Map type VkDataGraphProcessingEngineCreateInfoARM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM
+template <>
+struct LvlTypeMap<VkDataGraphProcessingEngineCreateInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM> {
+    typedef VkDataGraphProcessingEngineCreateInfoARM Type;
+};
+
+// Map type VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM> {
+    typedef VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM Type;
+};
+
+// Map type VkQueueFamilyDataGraphProcessingEnginePropertiesARM to id
+// VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM
+template <>
+struct LvlTypeMap<VkQueueFamilyDataGraphProcessingEnginePropertiesARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM> {
+    typedef VkQueueFamilyDataGraphProcessingEnginePropertiesARM Type;
+};
+
+// Map type VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM to id
+// VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM
+template <>
+struct LvlTypeMap<VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM> {
+    typedef VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM Type;
+};
+
+// Map type VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM> {
+    typedef VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM Type;
+};
+
+// Map type VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM to id
+// VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM
+template <>
+struct LvlTypeMap<VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM> {
+    typedef VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM Type;
+};
+
+// Map type VkPhysicalDevicePerStageDescriptorSetFeaturesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDevicePerStageDescriptorSetFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV> {
+    typedef VkPhysicalDevicePerStageDescriptorSetFeaturesNV Type;
+};
+
+// Map type VkPhysicalDeviceImageProcessing2FeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceImageProcessing2FeaturesQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM> {
+    typedef VkPhysicalDeviceImageProcessing2FeaturesQCOM Type;
+};
+
+// Map type VkPhysicalDeviceImageProcessing2PropertiesQCOM to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceImageProcessing2PropertiesQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM> {
+    typedef VkPhysicalDeviceImageProcessing2PropertiesQCOM Type;
+};
+
+// Map type VkSamplerBlockMatchWindowCreateInfoQCOM to id VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM
+template <>
+struct LvlTypeMap<VkSamplerBlockMatchWindowCreateInfoQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM> {
+    typedef VkSamplerBlockMatchWindowCreateInfoQCOM Type;
+};
+
+// Map type VkPhysicalDeviceCubicWeightsFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceCubicWeightsFeaturesQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM> {
+    typedef VkPhysicalDeviceCubicWeightsFeaturesQCOM Type;
+};
+
+// Map type VkSamplerCubicWeightsCreateInfoQCOM to id VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM
+template <>
+struct LvlTypeMap<VkSamplerCubicWeightsCreateInfoQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM> {
+    typedef VkSamplerCubicWeightsCreateInfoQCOM Type;
+};
+
+// Map type VkBlitImageCubicWeightsInfoQCOM to id VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM
+template <>
+struct LvlTypeMap<VkBlitImageCubicWeightsInfoQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM> {
+    typedef VkBlitImageCubicWeightsInfoQCOM Type;
+};
+
+// Map type VkPhysicalDeviceYcbcrDegammaFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceYcbcrDegammaFeaturesQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM> {
+    typedef VkPhysicalDeviceYcbcrDegammaFeaturesQCOM Type;
+};
+
+// Map type VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM to id
+// VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM
+template <>
+struct LvlTypeMap<VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM> {
+    typedef VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM Type;
+};
+
+// Map type VkPhysicalDeviceCubicClampFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceCubicClampFeaturesQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM> {
+    typedef VkPhysicalDeviceCubicClampFeaturesQCOM Type;
+};
+
+// Map type VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT> {
+    typedef VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT Type;
+};
+
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+// Map type VkScreenBufferPropertiesQNX to id VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX
+template <>
+struct LvlTypeMap<VkScreenBufferPropertiesQNX> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX> {
+    typedef VkScreenBufferPropertiesQNX Type;
+};
+
+#endif  // VK_USE_PLATFORM_SCREEN_QNX
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+// Map type VkScreenBufferFormatPropertiesQNX to id VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX
+template <>
+struct LvlTypeMap<VkScreenBufferFormatPropertiesQNX> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX> {
+    typedef VkScreenBufferFormatPropertiesQNX Type;
+};
+
+#endif  // VK_USE_PLATFORM_SCREEN_QNX
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+// Map type VkImportScreenBufferInfoQNX to id VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX
+template <>
+struct LvlTypeMap<VkImportScreenBufferInfoQNX> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX> {
+    typedef VkImportScreenBufferInfoQNX Type;
+};
+
+#endif  // VK_USE_PLATFORM_SCREEN_QNX
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+// Map type VkExternalFormatQNX to id VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX
+template <>
+struct LvlTypeMap<VkExternalFormatQNX> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX> {
+    typedef VkExternalFormatQNX Type;
+};
+
+#endif  // VK_USE_PLATFORM_SCREEN_QNX
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+// Map type VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX
+template <>
+struct LvlTypeMap<VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX> {
+    typedef VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX Type;
+};
+
+#endif  // VK_USE_PLATFORM_SCREEN_QNX
+// Map type VkPhysicalDeviceLayeredDriverPropertiesMSFT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceLayeredDriverPropertiesMSFT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT> {
+    typedef VkPhysicalDeviceLayeredDriverPropertiesMSFT Type;
+};
+
+// Map type VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV> {
+    typedef VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV Type;
+};
+
+// Map type VkPhysicalDeviceTileMemoryHeapFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceTileMemoryHeapFeaturesQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM> {
+    typedef VkPhysicalDeviceTileMemoryHeapFeaturesQCOM Type;
+};
+
+// Map type VkPhysicalDeviceTileMemoryHeapPropertiesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceTileMemoryHeapPropertiesQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM> {
+    typedef VkPhysicalDeviceTileMemoryHeapPropertiesQCOM Type;
+};
+
+// Map type VkTileMemoryRequirementsQCOM to id VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM
+template <>
+struct LvlTypeMap<VkTileMemoryRequirementsQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM> {
+    typedef VkTileMemoryRequirementsQCOM Type;
+};
+
+// Map type VkTileMemoryBindInfoQCOM to id VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM
+template <>
+struct LvlTypeMap<VkTileMemoryBindInfoQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM> {
+    typedef VkTileMemoryBindInfoQCOM Type;
+};
+
+// Map type VkTileMemorySizeInfoQCOM to id VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM
+template <>
+struct LvlTypeMap<VkTileMemorySizeInfoQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM> {
+    typedef VkTileMemorySizeInfoQCOM Type;
+};
+
+// Map type VkDecompressMemoryInfoEXT to id VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT
+template <>
+struct LvlTypeMap<VkDecompressMemoryInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT> {
+    typedef VkDecompressMemoryInfoEXT Type;
+};
+
+// Map type VkDisplaySurfaceStereoCreateInfoNV to id VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkDisplaySurfaceStereoCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV> {
+    typedef VkDisplaySurfaceStereoCreateInfoNV Type;
+};
+
+// Map type VkDisplayModeStereoPropertiesNV to id VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV
+template <>
+struct LvlTypeMap<VkDisplayModeStereoPropertiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV> {
+    typedef VkDisplayModeStereoPropertiesNV Type;
+};
+
+// Map type VkPhysicalDeviceRawAccessChainsFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceRawAccessChainsFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV> {
+    typedef VkPhysicalDeviceRawAccessChainsFeaturesNV Type;
+};
+
+// Map type VkExternalComputeQueueDeviceCreateInfoNV to id VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkExternalComputeQueueDeviceCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV> {
+    typedef VkExternalComputeQueueDeviceCreateInfoNV Type;
+};
+
+// Map type VkExternalComputeQueueCreateInfoNV to id VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkExternalComputeQueueCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV> {
+    typedef VkExternalComputeQueueCreateInfoNV Type;
+};
+
+// Map type VkExternalComputeQueueDataParamsNV to id VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV
+template <>
+struct LvlTypeMap<VkExternalComputeQueueDataParamsNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV> {
+    typedef VkExternalComputeQueueDataParamsNV Type;
+};
+
+// Map type VkPhysicalDeviceExternalComputeQueuePropertiesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceExternalComputeQueuePropertiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV> {
+    typedef VkPhysicalDeviceExternalComputeQueuePropertiesNV Type;
+};
+
+// Map type VkPhysicalDeviceCommandBufferInheritanceFeaturesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceCommandBufferInheritanceFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV> {
+    typedef VkPhysicalDeviceCommandBufferInheritanceFeaturesNV Type;
+};
+
+// Map type VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV> {
+    typedef VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV Type;
+};
+
+// Map type VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT> {
+    typedef VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceShaderFloat8FeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderFloat8FeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT> {
+    typedef VkPhysicalDeviceShaderFloat8FeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceRayTracingValidationFeaturesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceRayTracingValidationFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV> {
+    typedef VkPhysicalDeviceRayTracingValidationFeaturesNV Type;
+};
+
+// Map type VkPhysicalDeviceClusterAccelerationStructureFeaturesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceClusterAccelerationStructureFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV> {
+    typedef VkPhysicalDeviceClusterAccelerationStructureFeaturesNV Type;
+};
+
+// Map type VkPhysicalDeviceClusterAccelerationStructurePropertiesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceClusterAccelerationStructurePropertiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV> {
+    typedef VkPhysicalDeviceClusterAccelerationStructurePropertiesNV Type;
+};
+
+// Map type VkClusterAccelerationStructureClustersBottomLevelInputNV to id
+// VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV
+template <>
+struct LvlTypeMap<VkClusterAccelerationStructureClustersBottomLevelInputNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV> {
+    typedef VkClusterAccelerationStructureClustersBottomLevelInputNV Type;
+};
+
+// Map type VkClusterAccelerationStructureTriangleClusterInputNV to id
+// VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV
+template <>
+struct LvlTypeMap<VkClusterAccelerationStructureTriangleClusterInputNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV> {
+    typedef VkClusterAccelerationStructureTriangleClusterInputNV Type;
+};
+
+// Map type VkClusterAccelerationStructureMoveObjectsInputNV to id
+// VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV
+template <>
+struct LvlTypeMap<VkClusterAccelerationStructureMoveObjectsInputNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV> {
+    typedef VkClusterAccelerationStructureMoveObjectsInputNV Type;
+};
+
+// Map type VkClusterAccelerationStructureInputInfoNV to id VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV
+template <>
+struct LvlTypeMap<VkClusterAccelerationStructureInputInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV> {
+    typedef VkClusterAccelerationStructureInputInfoNV Type;
+};
+
+// Map type VkClusterAccelerationStructureCommandsInfoNV to id VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV
+template <>
+struct LvlTypeMap<VkClusterAccelerationStructureCommandsInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV> {
+    typedef VkClusterAccelerationStructureCommandsInfoNV Type;
+};
+
+// Map type VkAccelerationStructureBuildSizesInfoKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR
+template <>
+struct LvlTypeMap<VkAccelerationStructureBuildSizesInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR> {
+    typedef VkAccelerationStructureBuildSizesInfoKHR Type;
+};
+
+// Map type VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV to id
+// VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV
+template <>
+struct LvlTypeMap<VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV> {
+    typedef VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV Type;
+};
+
+// Map type VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV> {
+    typedef VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV Type;
+};
+
+// Map type VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV> {
+    typedef VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV Type;
+};
+
+// Map type VkPartitionedAccelerationStructureFlagsNV to id VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV
+template <>
+struct LvlTypeMap<VkPartitionedAccelerationStructureFlagsNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV> {
+    typedef VkPartitionedAccelerationStructureFlagsNV Type;
+};
+
+// Map type VkWriteDescriptorSetPartitionedAccelerationStructureNV to id
+// VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV
+template <>
+struct LvlTypeMap<VkWriteDescriptorSetPartitionedAccelerationStructureNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV> {
+    typedef VkWriteDescriptorSetPartitionedAccelerationStructureNV Type;
+};
+
+// Map type VkPartitionedAccelerationStructureInstancesInputNV to id
+// VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV
+template <>
+struct LvlTypeMap<VkPartitionedAccelerationStructureInstancesInputNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV> {
+    typedef VkPartitionedAccelerationStructureInstancesInputNV Type;
+};
+
+// Map type VkBuildPartitionedAccelerationStructureInfoNV to id VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV
+template <>
+struct LvlTypeMap<VkBuildPartitionedAccelerationStructureInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV> {
+    typedef VkBuildPartitionedAccelerationStructureInfoNV Type;
+};
+
+// Map type VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT> {
+    typedef VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT Type;
+};
+
+// Map type VkGeneratedCommandsMemoryRequirementsInfoEXT to id VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT
+template <>
+struct LvlTypeMap<VkGeneratedCommandsMemoryRequirementsInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT> {
+    typedef VkGeneratedCommandsMemoryRequirementsInfoEXT Type;
+};
+
+// Map type VkIndirectExecutionSetPipelineInfoEXT to id VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT
+template <>
+struct LvlTypeMap<VkIndirectExecutionSetPipelineInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT> {
+    typedef VkIndirectExecutionSetPipelineInfoEXT Type;
+};
+
+// Map type VkIndirectExecutionSetShaderLayoutInfoEXT to id VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT
+template <>
+struct LvlTypeMap<VkIndirectExecutionSetShaderLayoutInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT> {
+    typedef VkIndirectExecutionSetShaderLayoutInfoEXT Type;
+};
+
+// Map type VkIndirectExecutionSetShaderInfoEXT to id VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT
+template <>
+struct LvlTypeMap<VkIndirectExecutionSetShaderInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT> {
+    typedef VkIndirectExecutionSetShaderInfoEXT Type;
+};
+
+// Map type VkIndirectExecutionSetCreateInfoEXT to id VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkIndirectExecutionSetCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT> {
+    typedef VkIndirectExecutionSetCreateInfoEXT Type;
+};
+
+// Map type VkGeneratedCommandsInfoEXT to id VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT
+template <>
+struct LvlTypeMap<VkGeneratedCommandsInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT> {
+    typedef VkGeneratedCommandsInfoEXT Type;
+};
+
+// Map type VkWriteIndirectExecutionSetPipelineEXT to id VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT
+template <>
+struct LvlTypeMap<VkWriteIndirectExecutionSetPipelineEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT> {
+    typedef VkWriteIndirectExecutionSetPipelineEXT Type;
+};
+
+// Map type VkIndirectCommandsLayoutTokenEXT to id VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT
+template <>
+struct LvlTypeMap<VkIndirectCommandsLayoutTokenEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT> {
+    typedef VkIndirectCommandsLayoutTokenEXT Type;
+};
+
+// Map type VkIndirectCommandsLayoutCreateInfoEXT to id VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkIndirectCommandsLayoutCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT> {
+    typedef VkIndirectCommandsLayoutCreateInfoEXT Type;
+};
+
+// Map type VkGeneratedCommandsPipelineInfoEXT to id VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT
+template <>
+struct LvlTypeMap<VkGeneratedCommandsPipelineInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT> {
+    typedef VkGeneratedCommandsPipelineInfoEXT Type;
+};
+
+// Map type VkGeneratedCommandsShaderInfoEXT to id VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT
+template <>
+struct LvlTypeMap<VkGeneratedCommandsShaderInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT> {
+    typedef VkGeneratedCommandsShaderInfoEXT Type;
+};
+
+// Map type VkWriteIndirectExecutionSetShaderEXT to id VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT
+template <>
+struct LvlTypeMap<VkWriteIndirectExecutionSetShaderEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT> {
+    typedef VkWriteIndirectExecutionSetShaderEXT Type;
+};
+
+// Map type VkPhysicalDeviceImageAlignmentControlFeaturesMESA to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA
+template <>
+struct LvlTypeMap<VkPhysicalDeviceImageAlignmentControlFeaturesMESA> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA> {
+    typedef VkPhysicalDeviceImageAlignmentControlFeaturesMESA Type;
+};
+
+// Map type VkPhysicalDeviceImageAlignmentControlPropertiesMESA to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA
+template <>
+struct LvlTypeMap<VkPhysicalDeviceImageAlignmentControlPropertiesMESA> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA> {
+    typedef VkPhysicalDeviceImageAlignmentControlPropertiesMESA Type;
+};
+
+// Map type VkImageAlignmentControlCreateInfoMESA to id VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA
+template <>
+struct LvlTypeMap<VkImageAlignmentControlCreateInfoMESA> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA> {
+    typedef VkImageAlignmentControlCreateInfoMESA Type;
+};
+
+// Map type VkPushConstantBankInfoNV to id VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV
+template <>
+struct LvlTypeMap<VkPushConstantBankInfoNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV> {
+    typedef VkPushConstantBankInfoNV Type;
+};
+
+// Map type VkPhysicalDevicePushConstantBankFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDevicePushConstantBankFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV> {
+    typedef VkPhysicalDevicePushConstantBankFeaturesNV Type;
+};
+
+// Map type VkPhysicalDevicePushConstantBankPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDevicePushConstantBankPropertiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV> {
+    typedef VkPhysicalDevicePushConstantBankPropertiesNV Type;
+};
+
+// Map type VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT Type;
+};
+
+// Map type VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT> {
+    typedef VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceDepthClampControlFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDepthClampControlFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT> {
+    typedef VkPhysicalDeviceDepthClampControlFeaturesEXT Type;
+};
+
+// Map type VkPipelineViewportDepthClampControlCreateInfoEXT to id
+// VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkPipelineViewportDepthClampControlCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT> {
+    typedef VkPipelineViewportDepthClampControlCreateInfoEXT Type;
+};
+
+#ifdef VK_USE_PLATFORM_OHOS
+// Map type VkSurfaceCreateInfoOHOS to id VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS
+template <>
+struct LvlTypeMap<VkSurfaceCreateInfoOHOS> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS> {
+    typedef VkSurfaceCreateInfoOHOS Type;
+};
+
+#endif  // VK_USE_PLATFORM_OHOS
+// Map type VkPhysicalDeviceHdrVividFeaturesHUAWEI to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI
+template <>
+struct LvlTypeMap<VkPhysicalDeviceHdrVividFeaturesHUAWEI> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI> {
+    typedef VkPhysicalDeviceHdrVividFeaturesHUAWEI Type;
+};
+
+// Map type VkHdrVividDynamicMetadataHUAWEI to id VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI
+template <>
+struct LvlTypeMap<VkHdrVividDynamicMetadataHUAWEI> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI> {
+    typedef VkHdrVividDynamicMetadataHUAWEI Type;
+};
+
+// Map type VkCooperativeMatrixFlexibleDimensionsPropertiesNV to id
+// VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV
+template <>
+struct LvlTypeMap<VkCooperativeMatrixFlexibleDimensionsPropertiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV> {
+    typedef VkCooperativeMatrixFlexibleDimensionsPropertiesNV Type;
+};
+
+// Map type VkPhysicalDeviceCooperativeMatrix2FeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceCooperativeMatrix2FeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV> {
+    typedef VkPhysicalDeviceCooperativeMatrix2FeaturesNV Type;
+};
+
+// Map type VkPhysicalDeviceCooperativeMatrix2PropertiesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceCooperativeMatrix2PropertiesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV> {
+    typedef VkPhysicalDeviceCooperativeMatrix2PropertiesNV Type;
+};
+
+// Map type VkPhysicalDevicePipelineOpacityMicromapFeaturesARM to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM
+template <>
+struct LvlTypeMap<VkPhysicalDevicePipelineOpacityMicromapFeaturesARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM> {
+    typedef VkPhysicalDevicePipelineOpacityMicromapFeaturesARM Type;
+};
+
+#ifdef VK_USE_PLATFORM_METAL_EXT
+// Map type VkImportMemoryMetalHandleInfoEXT to id VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT
+template <>
+struct LvlTypeMap<VkImportMemoryMetalHandleInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT> {
+    typedef VkImportMemoryMetalHandleInfoEXT Type;
+};
+
+#endif  // VK_USE_PLATFORM_METAL_EXT
+#ifdef VK_USE_PLATFORM_METAL_EXT
+// Map type VkMemoryMetalHandlePropertiesEXT to id VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkMemoryMetalHandlePropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT> {
+    typedef VkMemoryMetalHandlePropertiesEXT Type;
+};
+
+#endif  // VK_USE_PLATFORM_METAL_EXT
+#ifdef VK_USE_PLATFORM_METAL_EXT
+// Map type VkMemoryGetMetalHandleInfoEXT to id VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT
+template <>
+struct LvlTypeMap<VkMemoryGetMetalHandleInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT> {
+    typedef VkMemoryGetMetalHandleInfoEXT Type;
+};
+
+#endif  // VK_USE_PLATFORM_METAL_EXT
+// Map type VkPhysicalDevicePerformanceCountersByRegionFeaturesARM to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM
+template <>
+struct LvlTypeMap<VkPhysicalDevicePerformanceCountersByRegionFeaturesARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM> {
+    typedef VkPhysicalDevicePerformanceCountersByRegionFeaturesARM Type;
+};
+
+// Map type VkPhysicalDevicePerformanceCountersByRegionPropertiesARM to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM
+template <>
+struct LvlTypeMap<VkPhysicalDevicePerformanceCountersByRegionPropertiesARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM> {
+    typedef VkPhysicalDevicePerformanceCountersByRegionPropertiesARM Type;
+};
+
+// Map type VkPerformanceCounterARM to id VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM
+template <>
+struct LvlTypeMap<VkPerformanceCounterARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM> {
+    typedef VkPerformanceCounterARM Type;
+};
+
+// Map type VkPerformanceCounterDescriptionARM to id VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM
+template <>
+struct LvlTypeMap<VkPerformanceCounterDescriptionARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM> {
+    typedef VkPerformanceCounterDescriptionARM Type;
+};
+
+// Map type VkRenderPassPerformanceCountersByRegionBeginInfoARM to id
+// VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM
+template <>
+struct LvlTypeMap<VkRenderPassPerformanceCountersByRegionBeginInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM> {
+    typedef VkRenderPassPerformanceCountersByRegionBeginInfoARM Type;
+};
+
+// Map type VkPhysicalDeviceShaderInstrumentationFeaturesARM to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES_ARM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderInstrumentationFeaturesARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES_ARM> {
+    typedef VkPhysicalDeviceShaderInstrumentationFeaturesARM Type;
+};
+
+// Map type VkPhysicalDeviceShaderInstrumentationPropertiesARM to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_PROPERTIES_ARM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderInstrumentationPropertiesARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_PROPERTIES_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_PROPERTIES_ARM> {
+    typedef VkPhysicalDeviceShaderInstrumentationPropertiesARM Type;
+};
+
+// Map type VkShaderInstrumentationCreateInfoARM to id VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_CREATE_INFO_ARM
+template <>
+struct LvlTypeMap<VkShaderInstrumentationCreateInfoARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_CREATE_INFO_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_CREATE_INFO_ARM> {
+    typedef VkShaderInstrumentationCreateInfoARM Type;
+};
+
+// Map type VkShaderInstrumentationMetricDescriptionARM to id VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_METRIC_DESCRIPTION_ARM
+template <>
+struct LvlTypeMap<VkShaderInstrumentationMetricDescriptionARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_METRIC_DESCRIPTION_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_METRIC_DESCRIPTION_ARM> {
+    typedef VkShaderInstrumentationMetricDescriptionARM Type;
+};
+
+// Map type VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT> {
+    typedef VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceFormatPackFeaturesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceFormatPackFeaturesARM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM> {
+    typedef VkPhysicalDeviceFormatPackFeaturesARM Type;
+};
+
+// Map type VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE
+template <>
+struct LvlTypeMap<VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE> {
+    typedef VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE Type;
+};
+
+// Map type VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE
+template <>
+struct LvlTypeMap<VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE> {
+    typedef VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE Type;
+};
+
+// Map type VkPipelineFragmentDensityMapLayeredCreateInfoVALVE to id
+// VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE
+template <>
+struct LvlTypeMap<VkPipelineFragmentDensityMapLayeredCreateInfoVALVE> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE> {
+    typedef VkPipelineFragmentDensityMapLayeredCreateInfoVALVE Type;
+};
+
+// Map type VkSetPresentConfigNV to id VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV
+template <>
+struct LvlTypeMap<VkSetPresentConfigNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV> {
+    typedef VkSetPresentConfigNV Type;
+};
+
+// Map type VkPhysicalDevicePresentMeteringFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDevicePresentMeteringFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV> {
+    typedef VkPhysicalDevicePresentMeteringFeaturesNV Type;
+};
+
+// Map type VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT> {
+    typedef VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceShader64BitIndexingFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShader64BitIndexingFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT> {
+    typedef VkPhysicalDeviceShader64BitIndexingFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceCustomResolveFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceCustomResolveFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT> {
+    typedef VkPhysicalDeviceCustomResolveFeaturesEXT Type;
+};
+
+// Map type VkBeginCustomResolveInfoEXT to id VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT
+template <>
+struct LvlTypeMap<VkBeginCustomResolveInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT> {
+    typedef VkBeginCustomResolveInfoEXT Type;
+};
+
+// Map type VkCustomResolveCreateInfoEXT to id VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT
+template <>
+struct LvlTypeMap<VkCustomResolveCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT> {
+    typedef VkCustomResolveCreateInfoEXT Type;
+};
+
+// Map type VkDataGraphPipelineBuiltinModelCreateInfoQCOM to id VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM
+template <>
+struct LvlTypeMap<VkDataGraphPipelineBuiltinModelCreateInfoQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM> {
+    typedef VkDataGraphPipelineBuiltinModelCreateInfoQCOM Type;
+};
+
+// Map type VkPhysicalDeviceDataGraphModelFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM
+template <>
+struct LvlTypeMap<VkPhysicalDeviceDataGraphModelFeaturesQCOM> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM> {
+    typedef VkPhysicalDeviceDataGraphModelFeaturesQCOM Type;
+};
+
+// Map type VkPhysicalDeviceShaderLongVectorFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderLongVectorFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT> {
+    typedef VkPhysicalDeviceShaderLongVectorFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceShaderLongVectorPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderLongVectorPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceShaderLongVectorPropertiesEXT Type;
+};
+
+// Map type VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC
+template <>
+struct LvlTypeMap<VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC> {
+    typedef VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC Type;
+};
+
+// Map type VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT> {
+    typedef VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT Type;
+};
+
+// Map type VkComputeOccupancyPriorityParametersNV to id VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV
+template <>
+struct LvlTypeMap<VkComputeOccupancyPriorityParametersNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV> {
+    typedef VkComputeOccupancyPriorityParametersNV Type;
+};
+
+// Map type VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV
+template <>
+struct LvlTypeMap<VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV> {
+    typedef VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV Type;
+};
+
+// Map type VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT> {
+    typedef VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT Type;
+};
+
+#ifdef VK_USE_PLATFORM_UBM_SEC
+// Map type VkUbmSurfaceCreateInfoSEC to id VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC
+template <>
+struct LvlTypeMap<VkUbmSurfaceCreateInfoSEC> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC> {
+    typedef VkUbmSurfaceCreateInfoSEC Type;
+};
+
+#endif  // VK_USE_PLATFORM_UBM_SEC
+// Map type VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE
+template <>
+struct LvlTypeMap<VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE> {
+    typedef VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE Type;
+};
+
+// Map type VkAccelerationStructureGeometryTrianglesDataKHR to id
+// VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR
+template <>
+struct LvlTypeMap<VkAccelerationStructureGeometryTrianglesDataKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR> {
+    typedef VkAccelerationStructureGeometryTrianglesDataKHR Type;
+};
+
+// Map type VkAccelerationStructureGeometryAabbsDataKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR
+template <>
+struct LvlTypeMap<VkAccelerationStructureGeometryAabbsDataKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR> {
+    typedef VkAccelerationStructureGeometryAabbsDataKHR Type;
+};
+
+// Map type VkAccelerationStructureGeometryInstancesDataKHR to id
+// VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR
+template <>
+struct LvlTypeMap<VkAccelerationStructureGeometryInstancesDataKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR> {
+    typedef VkAccelerationStructureGeometryInstancesDataKHR Type;
+};
+
+// Map type VkAccelerationStructureGeometryKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR
+template <>
+struct LvlTypeMap<VkAccelerationStructureGeometryKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR> {
+    typedef VkAccelerationStructureGeometryKHR Type;
+};
+
+// Map type VkAccelerationStructureBuildGeometryInfoKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR
+template <>
+struct LvlTypeMap<VkAccelerationStructureBuildGeometryInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR> {
+    typedef VkAccelerationStructureBuildGeometryInfoKHR Type;
+};
+
+// Map type VkAccelerationStructureCreateInfoKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkAccelerationStructureCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR> {
+    typedef VkAccelerationStructureCreateInfoKHR Type;
+};
+
+// Map type VkWriteDescriptorSetAccelerationStructureKHR to id VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR
+template <>
+struct LvlTypeMap<VkWriteDescriptorSetAccelerationStructureKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR> {
+    typedef VkWriteDescriptorSetAccelerationStructureKHR Type;
+};
+
+// Map type VkPhysicalDeviceAccelerationStructureFeaturesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceAccelerationStructureFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR> {
+    typedef VkPhysicalDeviceAccelerationStructureFeaturesKHR Type;
+};
+
+// Map type VkPhysicalDeviceAccelerationStructurePropertiesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceAccelerationStructurePropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR> {
+    typedef VkPhysicalDeviceAccelerationStructurePropertiesKHR Type;
+};
+
+// Map type VkAccelerationStructureDeviceAddressInfoKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR
+template <>
+struct LvlTypeMap<VkAccelerationStructureDeviceAddressInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR> {
+    typedef VkAccelerationStructureDeviceAddressInfoKHR Type;
+};
+
+// Map type VkAccelerationStructureVersionInfoKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR
+template <>
+struct LvlTypeMap<VkAccelerationStructureVersionInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR> {
+    typedef VkAccelerationStructureVersionInfoKHR Type;
+};
+
+// Map type VkCopyAccelerationStructureToMemoryInfoKHR to id VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR
+template <>
+struct LvlTypeMap<VkCopyAccelerationStructureToMemoryInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR> {
+    typedef VkCopyAccelerationStructureToMemoryInfoKHR Type;
+};
+
+// Map type VkCopyMemoryToAccelerationStructureInfoKHR to id VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR
+template <>
+struct LvlTypeMap<VkCopyMemoryToAccelerationStructureInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR> {
+    typedef VkCopyMemoryToAccelerationStructureInfoKHR Type;
+};
+
+// Map type VkCopyAccelerationStructureInfoKHR to id VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR
+template <>
+struct LvlTypeMap<VkCopyAccelerationStructureInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR> {
+    typedef VkCopyAccelerationStructureInfoKHR Type;
+};
+
+// Map type VkRayTracingShaderGroupCreateInfoKHR to id VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkRayTracingShaderGroupCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR> {
+    typedef VkRayTracingShaderGroupCreateInfoKHR Type;
+};
+
+// Map type VkRayTracingPipelineInterfaceCreateInfoKHR to id VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkRayTracingPipelineInterfaceCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR> {
+    typedef VkRayTracingPipelineInterfaceCreateInfoKHR Type;
+};
+
+// Map type VkRayTracingPipelineCreateInfoKHR to id VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR
+template <>
+struct LvlTypeMap<VkRayTracingPipelineCreateInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR> {
+    typedef VkRayTracingPipelineCreateInfoKHR Type;
+};
+
+// Map type VkPhysicalDeviceRayTracingPipelineFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceRayTracingPipelineFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR> {
+    typedef VkPhysicalDeviceRayTracingPipelineFeaturesKHR Type;
+};
+
+// Map type VkPhysicalDeviceRayTracingPipelinePropertiesKHR to id
+// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceRayTracingPipelinePropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR> {
+    typedef VkPhysicalDeviceRayTracingPipelinePropertiesKHR Type;
+};
+
+// Map type VkPhysicalDeviceRayQueryFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR
+template <>
+struct LvlTypeMap<VkPhysicalDeviceRayQueryFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR> {
+    typedef VkPhysicalDeviceRayQueryFeaturesKHR Type;
+};
+
+// Map type VkPhysicalDeviceMeshShaderFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMeshShaderFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT> {
+    typedef VkPhysicalDeviceMeshShaderFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceMeshShaderPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT
+template <>
+struct LvlTypeMap<VkPhysicalDeviceMeshShaderPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT;
+};
+
+template <>
+struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceMeshShaderPropertiesEXT Type;
+};
+
+// Header "base class" for pNext chain traversal
+struct LvlGenericHeader {
+    VkStructureType sType;
+    const LvlGenericHeader *pNext;
+};
+struct LvlGenericModHeader {
+    VkStructureType sType;
+    LvlGenericModHeader *pNext;
+};
+
+// Find an entry of the given type in the pNext chain
+template <typename T>
+const T *lvl_find_in_chain(const void *next) {
+    const LvlGenericHeader *current = reinterpret_cast<const LvlGenericHeader *>(next);
+    const T *found = nullptr;
+    while (current) {
+        if (LvlTypeMap<T>::kSType == current->sType) {
+            found = reinterpret_cast<const T *>(current);
+            current = nullptr;
+        } else {
+            current = current->pNext;
+        }
+    }
+    return found;
+}
+// Find an entry of the given type in the pNext chain
+template <typename T>
+T *lvl_find_mod_in_chain(void *next) {
+    LvlGenericModHeader *current = reinterpret_cast<LvlGenericModHeader *>(next);
+    T *found = nullptr;
+    while (current) {
+        if (LvlTypeMap<T>::kSType == current->sType) {
+            found = reinterpret_cast<T *>(current);
+            current = nullptr;
+        } else {
+            current = current->pNext;
+        }
+    }
+    return found;
+}
+
+// Init the header of an sType struct with pNext
+template <typename T>
+T lvl_init_struct(void *p_next) {
+    T out = {};
+    out.sType = LvlTypeMap<T>::kSType;
+    out.pNext = p_next;
+    return out;
+}
+
+// Init the header of an sType struct
+template <typename T>
+T lvl_init_struct() {
+    T out = {};
+    out.sType = LvlTypeMap<T>::kSType;
+    return out;
+}
diff --git a/tools/Vulkan-Tools/icd/mock_icd.cpp b/tools/Vulkan-Tools/icd/mock_icd.cpp
new file mode 100644
index 00000000..182c2d87
--- /dev/null
+++ b/tools/Vulkan-Tools/icd/mock_icd.cpp
@@ -0,0 +1,182 @@
+/*
+** Copyright (c) 2015-2018, 2023 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#include "mock_icd.h"
+#include "function_definitions.h"
+
+namespace vkmock {
+
+static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetPhysicalDeviceProcAddr(VkInstance instance, const char* funcName) {
+    // TODO: This function should only care about physical device functions and return nullptr for other functions
+    const auto& item = name_to_funcptr_map.find(funcName);
+    if (item != name_to_funcptr_map.end()) {
+        return reinterpret_cast<PFN_vkVoidFunction>(item->second);
+    }
+    // Mock should intercept all functions so if we get here just return null
+    return nullptr;
+}
+
+#if defined(__GNUC__) && __GNUC__ >= 4
+#define EXPORT __attribute__((visibility("default")))
+#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
+#define EXPORT __attribute__((visibility("default")))
+#else
+#define EXPORT
+#endif
+
+}  // namespace vkmock
+
+extern "C" {
+
+EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetInstanceProcAddr(VkInstance instance, const char* pName) {
+    if (!vkmock::negotiate_loader_icd_interface_called) {
+        vkmock::loader_interface_version = 1;
+    }
+    return vkmock::GetInstanceProcAddr(instance, pName);
+}
+
+EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetPhysicalDeviceProcAddr(VkInstance instance, const char* pName) {
+    return vkmock::GetPhysicalDeviceProcAddr(instance, pName);
+}
+
+EXPORT VKAPI_ATTR VkResult VKAPI_CALL vk_icdNegotiateLoaderICDInterfaceVersion(uint32_t* pSupportedVersion) {
+    vkmock::negotiate_loader_icd_interface_called = true;
+    vkmock::loader_interface_version = *pSupportedVersion;
+    if (*pSupportedVersion > vkmock::SUPPORTED_LOADER_ICD_INTERFACE_VERSION) {
+        *pSupportedVersion = vkmock::SUPPORTED_LOADER_ICD_INTERFACE_VERSION;
+    }
+    return VK_SUCCESS;
+}
+
+EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
+                                                      const VkAllocationCallbacks* pAllocator) {
+    vkmock::DestroySurfaceKHR(instance, surface, pAllocator);
+}
+
+EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                           uint32_t queueFamilyIndex, VkSurfaceKHR surface,
+                                                                           VkBool32* pSupported) {
+    return vkmock::GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
+}
+
+EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice,
+                                                                                VkSurfaceKHR surface,
+                                                                                VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
+    return vkmock::GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
+}
+
+EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+                                                                           uint32_t* pSurfaceFormatCount,
+                                                                           VkSurfaceFormatKHR* pSurfaceFormats) {
+    return vkmock::GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
+}
+
+EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice,
+                                                                                VkSurfaceKHR surface, uint32_t* pPresentModeCount,
+                                                                                VkPresentModeKHR* pPresentModes) {
+    return vkmock::GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
+}
+
+EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(VkInstance instance,
+                                                                     const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
+                                                                     const VkAllocationCallbacks* pAllocator,
+                                                                     VkSurfaceKHR* pSurface) {
+    return vkmock::CreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+}
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+
+EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
+                                                             const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    return vkmock::CreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+}
+#endif /* VK_USE_PLATFORM_XLIB_KHR */
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+
+EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
+                                                            const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    return vkmock::CreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+}
+#endif /* VK_USE_PLATFORM_XCB_KHR */
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+
+EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(VkInstance instance,
+                                                                const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
+                                                                const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    return vkmock::CreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+}
+#endif /* VK_USE_PLATFORM_WAYLAND_KHR */
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+
+EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(VkInstance instance,
+                                                                const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+                                                                const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    return vkmock::CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+}
+#endif /* VK_USE_PLATFORM_ANDROID_KHR */
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
+                                                              const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    return vkmock::CreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+}
+#endif /* VK_USE_PLATFORM_WIN32_KHR */
+
+EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface,
+                                                                             VkDeviceGroupPresentModeFlagsKHR* pModes) {
+    return vkmock::GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
+}
+
+EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+                                                                              uint32_t* pRectCount, VkRect2D* pRects) {
+    return vkmock::GetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects);
+}
+
+#ifdef VK_USE_PLATFORM_VI_NN
+
+EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo,
+                                                          const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    return vkmock::CreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface);
+}
+#endif /* VK_USE_PLATFORM_VI_NN */
+
+EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice,
+                                                                                 VkSurfaceKHR surface,
+                                                                                 VkSurfaceCapabilities2EXT* pSurfaceCapabilities) {
+    return vkmock::GetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities);
+}
+
+#ifdef VK_USE_PLATFORM_IOS_MVK
+
+EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
+                                                            const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    return vkmock::CreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
+}
+#endif /* VK_USE_PLATFORM_IOS_MVK */
+
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+
+EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
+                                                              const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    return vkmock::CreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
+}
+#endif /* VK_USE_PLATFORM_MACOS_MVK */
+
+}  // end extern "C"
diff --git a/tools/Vulkan-Tools/icd/mock_icd.h b/tools/Vulkan-Tools/icd/mock_icd.h
new file mode 100644
index 00000000..f5145cd7
--- /dev/null
+++ b/tools/Vulkan-Tools/icd/mock_icd.h
@@ -0,0 +1,252 @@
+/*
+** Copyright (c) 2015-2018, 2023 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#pragma once
+
+#include <stdlib.h>
+#include <cstring>
+
+#include <algorithm>
+#include <array>
+#include <mutex>
+#include <unordered_set>
+#include <unordered_map>
+#include <string>
+#include <vector>
+
+#include "vk_video/vulkan_video_codecs_common.h"
+#include "vk_video/vulkan_video_codec_h264std.h"
+#include "vk_video/vulkan_video_codec_h264std_decode.h"
+#include "vk_video/vulkan_video_codec_h264std_encode.h"
+#include "vk_video/vulkan_video_codec_h265std.h"
+#include "vk_video/vulkan_video_codec_h265std_decode.h"
+#include "vk_video/vulkan_video_codec_h265std_encode.h"
+#include "vulkan/vulkan.h"
+
+#include "vulkan/vk_icd.h"
+#include "vk_typemap_helper.h"
+
+namespace vkmock {
+
+using mutex_t = std::mutex;
+using lock_guard_t = std::lock_guard<mutex_t>;
+using unique_lock_t = std::unique_lock<mutex_t>;
+
+static mutex_t global_lock;
+static uint64_t global_unique_handle = 1;
+static const uint32_t SUPPORTED_LOADER_ICD_INTERFACE_VERSION = 5;
+static uint32_t loader_interface_version = 0;
+static bool negotiate_loader_icd_interface_called = false;
+static void* CreateDispObjHandle() {
+    auto handle = new VK_LOADER_DATA;
+    set_loader_magic_value(handle);
+    return handle;
+}
+static void DestroyDispObjHandle(void* handle) { delete reinterpret_cast<VK_LOADER_DATA*>(handle); }
+
+static constexpr uint32_t icd_physical_device_count = 1;
+static std::unordered_map<VkInstance, std::array<VkPhysicalDevice, icd_physical_device_count>> physical_device_map;
+static std::unordered_map<VkPhysicalDevice, std::unordered_set<VkDisplayKHR>> display_map;
+
+// Map device memory handle to any mapped allocations that we'll need to free on unmap
+static std::unordered_map<VkDeviceMemory, std::vector<void*>> mapped_memory_map;
+
+// Map device memory allocation handle to the size
+static std::unordered_map<VkDeviceMemory, VkDeviceSize> allocated_memory_size_map;
+
+static std::unordered_map<VkDevice, std::unordered_map<uint32_t, std::unordered_map<uint32_t, VkQueue>>> queue_map;
+static VkDeviceAddress current_available_address = 0x10000000;
+struct BufferState {
+    VkDeviceSize size;
+    VkDeviceAddress address;
+};
+static std::unordered_map<VkDevice, std::unordered_map<VkBuffer, BufferState>> buffer_map;
+static std::unordered_map<VkDevice, std::unordered_map<VkImage, VkDeviceSize>> image_memory_size_map;
+static std::unordered_map<VkDevice, std::unordered_set<VkCommandPool>> command_pool_map;
+static std::unordered_map<VkCommandPool, std::vector<VkCommandBuffer>> command_pool_buffer_map;
+
+static constexpr uint32_t icd_swapchain_image_count = 1;
+static std::unordered_map<VkSwapchainKHR, VkImage[icd_swapchain_image_count]> swapchain_image_map;
+
+// TODO: Would like to codegen this but limits aren't in XML
+static VkPhysicalDeviceLimits SetLimits(VkPhysicalDeviceLimits* limits) {
+    limits->maxImageDimension1D = 4096;
+    limits->maxImageDimension2D = 4096;
+    limits->maxImageDimension3D = 256;
+    limits->maxImageDimensionCube = 4096;
+    limits->maxImageArrayLayers = 256;
+    limits->maxTexelBufferElements = 65536;
+    limits->maxUniformBufferRange = 16384;
+    limits->maxStorageBufferRange = 134217728;
+    limits->maxPushConstantsSize = 128;
+    limits->maxMemoryAllocationCount = 4096;
+    limits->maxSamplerAllocationCount = 4000;
+    limits->bufferImageGranularity = 1;
+    limits->sparseAddressSpaceSize = 2147483648;
+    limits->maxBoundDescriptorSets = 4;
+    limits->maxPerStageDescriptorSamplers = 16;
+    limits->maxPerStageDescriptorUniformBuffers = 12;
+    limits->maxPerStageDescriptorStorageBuffers = 4;
+    limits->maxPerStageDescriptorSampledImages = 16;
+    limits->maxPerStageDescriptorStorageImages = 4;
+    limits->maxPerStageDescriptorInputAttachments = 4;
+    limits->maxPerStageResources = 128;
+    limits->maxDescriptorSetSamplers = 96;
+    limits->maxDescriptorSetUniformBuffers = 72;
+    limits->maxDescriptorSetUniformBuffersDynamic = 8;
+    limits->maxDescriptorSetStorageBuffers = 24;
+    limits->maxDescriptorSetStorageBuffersDynamic = 4;
+    limits->maxDescriptorSetSampledImages = 96;
+    limits->maxDescriptorSetStorageImages = 24;
+    limits->maxDescriptorSetInputAttachments = 4;
+    limits->maxVertexInputAttributes = 16;
+    limits->maxVertexInputBindings = 16;
+    limits->maxVertexInputAttributeOffset = 2047;
+    limits->maxVertexInputBindingStride = 2048;
+    limits->maxVertexOutputComponents = 64;
+    limits->maxTessellationGenerationLevel = 64;
+    limits->maxTessellationPatchSize = 32;
+    limits->maxTessellationControlPerVertexInputComponents = 64;
+    limits->maxTessellationControlPerVertexOutputComponents = 64;
+    limits->maxTessellationControlPerPatchOutputComponents = 120;
+    limits->maxTessellationControlTotalOutputComponents = 2048;
+    limits->maxTessellationEvaluationInputComponents = 64;
+    limits->maxTessellationEvaluationOutputComponents = 64;
+    limits->maxGeometryShaderInvocations = 32;
+    limits->maxGeometryInputComponents = 64;
+    limits->maxGeometryOutputComponents = 64;
+    limits->maxGeometryOutputVertices = 256;
+    limits->maxGeometryTotalOutputComponents = 1024;
+    limits->maxFragmentInputComponents = 64;
+    limits->maxFragmentOutputAttachments = 4;
+    limits->maxFragmentDualSrcAttachments = 1;
+    limits->maxFragmentCombinedOutputResources = 4;
+    limits->maxComputeSharedMemorySize = 16384;
+    limits->maxComputeWorkGroupCount[0] = 65535;
+    limits->maxComputeWorkGroupCount[1] = 65535;
+    limits->maxComputeWorkGroupCount[2] = 65535;
+    limits->maxComputeWorkGroupInvocations = 128;
+    limits->maxComputeWorkGroupSize[0] = 128;
+    limits->maxComputeWorkGroupSize[1] = 128;
+    limits->maxComputeWorkGroupSize[2] = 64;
+    limits->subPixelPrecisionBits = 4;
+    limits->subTexelPrecisionBits = 4;
+    limits->mipmapPrecisionBits = 4;
+    limits->maxDrawIndexedIndexValue = UINT32_MAX;
+    limits->maxDrawIndirectCount = UINT16_MAX;
+    limits->maxSamplerLodBias = 2.0f;
+    limits->maxSamplerAnisotropy = 16;
+    limits->maxViewports = 16;
+    limits->maxViewportDimensions[0] = 4096;
+    limits->maxViewportDimensions[1] = 4096;
+    limits->viewportBoundsRange[0] = -8192;
+    limits->viewportBoundsRange[1] = 8191;
+    limits->viewportSubPixelBits = 0;
+    limits->minMemoryMapAlignment = 64;
+    limits->minTexelBufferOffsetAlignment = 16;
+    limits->minUniformBufferOffsetAlignment = 16;
+    limits->minStorageBufferOffsetAlignment = 16;
+    limits->minTexelOffset = -8;
+    limits->maxTexelOffset = 7;
+    limits->minTexelGatherOffset = -8;
+    limits->maxTexelGatherOffset = 7;
+    limits->minInterpolationOffset = 0.0f;
+    limits->maxInterpolationOffset = 0.5f;
+    limits->subPixelInterpolationOffsetBits = 4;
+    limits->maxFramebufferWidth = 4096;
+    limits->maxFramebufferHeight = 4096;
+    limits->maxFramebufferLayers = 256;
+    limits->framebufferColorSampleCounts = 0x7F;
+    limits->framebufferDepthSampleCounts = 0x7F;
+    limits->framebufferStencilSampleCounts = 0x7F;
+    limits->framebufferNoAttachmentsSampleCounts = 0x7F;
+    limits->maxColorAttachments = 4;
+    limits->sampledImageColorSampleCounts = 0x7F;
+    limits->sampledImageIntegerSampleCounts = 0x7F;
+    limits->sampledImageDepthSampleCounts = 0x7F;
+    limits->sampledImageStencilSampleCounts = 0x7F;
+    limits->storageImageSampleCounts = 0x7F;
+    limits->maxSampleMaskWords = 1;
+    limits->timestampComputeAndGraphics = VK_TRUE;
+    limits->timestampPeriod = 1;
+    limits->maxClipDistances = 8;
+    limits->maxCullDistances = 8;
+    limits->maxCombinedClipAndCullDistances = 8;
+    limits->discreteQueuePriorities = 2;
+    limits->pointSizeRange[0] = 1.0f;
+    limits->pointSizeRange[1] = 64.0f;
+    limits->lineWidthRange[0] = 1.0f;
+    limits->lineWidthRange[1] = 8.0f;
+    limits->pointSizeGranularity = 1.0f;
+    limits->lineWidthGranularity = 1.0f;
+    limits->strictLines = VK_TRUE;
+    limits->standardSampleLocations = VK_TRUE;
+    limits->optimalBufferCopyOffsetAlignment = 1;
+    limits->optimalBufferCopyRowPitchAlignment = 1;
+    limits->nonCoherentAtomSize = 256;
+
+    return *limits;
+}
+
+void SetBoolArrayTrue(VkBool32* bool_array, uint32_t num_bools) {
+    for (uint32_t i = 0; i < num_bools; ++i) {
+        bool_array[i] = VK_TRUE;
+    }
+}
+
+VkDeviceSize GetImageSizeFromCreateInfo(const VkImageCreateInfo* pCreateInfo) {
+    VkDeviceSize size = pCreateInfo->extent.width;
+    size *= pCreateInfo->extent.height;
+    size *= pCreateInfo->extent.depth;
+    // TODO: A pixel size is 32 bytes. This accounts for the largest possible pixel size of any format. It could be changed to more
+    // accurate size if need be.
+    size *= 32;
+    size *= pCreateInfo->arrayLayers;
+    size *= (pCreateInfo->mipLevels > 1 ? 2 : 1);
+
+    switch (pCreateInfo->format) {
+        case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
+        case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
+        case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
+        case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
+        case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
+        case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
+        case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
+        case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
+        case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
+        case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
+        case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
+        case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
+            size *= 3;
+            break;
+        case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
+        case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
+        case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
+        case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
+        case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
+        case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
+        case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
+        case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
+            size *= 2;
+            break;
+        default:
+            break;
+    }
+
+    return size;
+}
+
+}  // namespace vkmock
diff --git a/tools/Vulkan-Tools/scripts/CMakeLists.txt b/tools/Vulkan-Tools/scripts/CMakeLists.txt
new file mode 100644
index 00000000..65c8bade
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/CMakeLists.txt
@@ -0,0 +1,135 @@
+# ~~~
+# Copyright (c) 2023 LunarG, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ~~~
+
+option(UPDATE_DEPS "Run update_deps.py for user")
+if (UPDATE_DEPS)
+    find_package(Python3 REQUIRED QUIET)
+
+    set(update_dep_py "${CMAKE_CURRENT_LIST_DIR}/update_deps.py")
+    set(known_good_json "${CMAKE_CURRENT_LIST_DIR}/known_good.json")
+
+    set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${update_dep_py} ${known_good_json})
+
+    list(APPEND update_dep_command "${update_dep_py}")
+    list(APPEND update_dep_command "--generator")
+    list(APPEND update_dep_command "${CMAKE_GENERATOR}")
+
+    if (CMAKE_GENERATOR_PLATFORM)
+        list(APPEND update_dep_command "--arch")
+        list(APPEND update_dep_command "${CMAKE_GENERATOR_PLATFORM}")
+    endif()
+
+    if (NOT CMAKE_BUILD_TYPE)
+        message(WARNING "CMAKE_BUILD_TYPE not set. Using Debug for dependency build type")
+        set(_build_type Debug)
+    else()
+        set(_build_type ${CMAKE_BUILD_TYPE})
+    endif()
+    list(APPEND update_dep_command "--config")
+    list(APPEND update_dep_command "${_build_type}")
+    list(APPEND update_dep_command "--api")
+    list(APPEND update_dep_command "${API_TYPE}")
+
+    set(UPDATE_DEPS_DIR_SUFFIX "${_build_type}")
+    if (CMAKE_CROSSCOMPILING)
+        set(UPDATE_DEPS_DIR_SUFFIX "${CMAKE_SYSTEM_NAME}/${UPDATE_DEPS_DIR_SUFFIX}/${CMAKE_SYSTEM_PROCESSOR}")
+    else()
+        math(EXPR bitness "8 * ${CMAKE_SIZEOF_VOID_P}")
+        set(UPDATE_DEPS_DIR_SUFFIX "${UPDATE_DEPS_DIR_SUFFIX}/${bitness}")
+    endif()
+    set(UPDATE_DEPS_DIR "${PROJECT_SOURCE_DIR}/external/${UPDATE_DEPS_DIR_SUFFIX}" CACHE PATH "Location where update_deps.py installs packages")
+    list(APPEND update_dep_command "--dir" )
+    list(APPEND update_dep_command "${UPDATE_DEPS_DIR}")
+
+    if (NOT BUILD_TESTS)
+        list(APPEND update_dep_command "--optional=tests")
+    endif()
+
+    if (UPDATE_DEPS_SKIP_EXISTING_INSTALL)
+        list(APPEND update_dep_command "--skip-existing-install")
+    endif()
+
+    list(APPEND cmake_vars "CMAKE_TOOLCHAIN_FILE")
+
+    # Avoids manually setting CMAKE_SYSTEM_NAME unless it's needed:
+    # https://cmake.org/cmake/help/latest/variable/CMAKE_CROSSCOMPILING.html
+    if (NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "${CMAKE_HOST_SYSTEM_NAME}")
+        list(APPEND cmake_vars "CMAKE_SYSTEM_NAME")
+    endif()
+    if (APPLE)
+        list(APPEND cmake_vars "CMAKE_OSX_ARCHITECTURES" "CMAKE_OSX_DEPLOYMENT_TARGET")
+    endif()
+    if (NOT MSVC_IDE)
+        list(APPEND cmake_vars "CMAKE_CXX_COMPILER" "CMAKE_C_COMPILER" "CMAKE_ASM_COMPILER")
+    endif()
+    if (ANDROID)
+        list(APPEND cmake_vars "ANDROID_PLATFORM" "CMAKE_ANDROID_ARCH_ABI" "CMAKE_ANDROID_STL_TYPE" "CMAKE_ANDROID_RTTI" "CMAKE_ANDROID_EXCEPTIONS" "ANDROID_USE_LEGACY_TOOLCHAIN_FILE")
+    endif()
+
+    set(cmake_var)
+    foreach(var IN LISTS cmake_vars)
+        if (DEFINED ${var})
+            list(APPEND update_dep_command "--cmake_var")
+            list(APPEND update_dep_command "${var}=${${var}}")
+        endif()
+    endforeach()
+
+    if (cmake_var)
+        list(APPEND update_dep_command "${cmake_var}")
+    endif()
+
+    file(TIMESTAMP ${update_dep_py} timestamp_1)
+    file(TIMESTAMP ${known_good_json} timestamp_2)
+
+    string("MD5" md5_hash "${timestamp_1}-${timestamp_2}-${update_dep_command}")
+
+    set(UPDATE_DEPS_HASH "0" CACHE STRING "Default value until we run update_deps.py")
+    mark_as_advanced(UPDATE_DEPS_HASH)
+
+    if ("${UPDATE_DEPS_HASH}" STREQUAL "0")
+        list(APPEND update_dep_command "--clean-build")
+        list(APPEND update_dep_command "--clean-install")
+    endif()
+
+    if ("${md5_hash}" STREQUAL $CACHE{UPDATE_DEPS_HASH})
+        message(DEBUG "update_deps.py: no work to do.")
+    else()
+        execute_process(
+            COMMAND ${Python3_EXECUTABLE} ${update_dep_command}
+            RESULT_VARIABLE _update_deps_result
+        )
+        if (NOT (${_update_deps_result} EQUAL 0))
+            message(FATAL_ERROR "Could not run update_deps.py which is necessary to download dependencies.")
+        endif()
+        set(UPDATE_DEPS_HASH ${md5_hash} CACHE STRING "Ensure we only run update_deps.py when we need to." FORCE)
+        include("${UPDATE_DEPS_DIR}/helper.cmake")
+    endif()
+endif()
+if (VULKAN_HEADERS_INSTALL_DIR)
+    list(APPEND CMAKE_PREFIX_PATH ${VULKAN_HEADERS_INSTALL_DIR})
+endif()
+if (GOOGLETEST_INSTALL_DIR)
+    list(APPEND CMAKE_PREFIX_PATH ${GOOGLETEST_INSTALL_DIR})
+endif()
+if (VULKAN_LOADER_INSTALL_DIR)
+    list(APPEND CMAKE_PREFIX_PATH ${VULKAN_LOADER_INSTALL_DIR})
+endif()
+
+if (CMAKE_CROSSCOMPILING)
+    set(CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH} ${CMAKE_PREFIX_PATH} PARENT_SCOPE)
+else()
+    set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} PARENT_SCOPE)
+endif()
diff --git a/tools/Vulkan-Tools/scripts/android.py b/tools/Vulkan-Tools/scripts/android.py
new file mode 100755
index 00000000..20cc69d4
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/android.py
@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+# Copyright (c) 2023 Valve Corporation
+# Copyright (c) 2023 LunarG, Inc.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# NOTE: Android this documentation is crucial for understanding the layout of the NDK.
+# https://android.googlesource.com/platform/ndk/+/master/docs/BuildSystemMaintainers.md
+
+# NOTE: Environment variables we can rely on users/environments setting.
+# https://github.com/actions/runner-images/blob/main/images/linux/Ubuntu2204-Readme.md#environment-variables-2
+
+import argparse
+import os
+import sys
+import shutil
+import subprocess
+
+# helper to define paths relative to the repo root
+def RepoRelative(path):
+    return os.path.abspath(os.path.join(os.path.dirname(__file__), '..', path))
+
+# Points to the directory containing the top level CMakeLists.txt
+PROJECT_SRC_DIR = os.path.abspath(os.path.join(os.path.split(os.path.abspath(__file__))[0], '..'))
+if not os.path.isfile(f'{PROJECT_SRC_DIR}/CMakeLists.txt'):
+    print(f'PROJECT_SRC_DIR invalid! {PROJECT_SRC_DIR}')
+    sys.exit(1)
+
+# Runs a command in a directory and returns its return code.
+# Directory is project root by default, or a relative path from project root
+def RunShellCmd(command, start_dir = PROJECT_SRC_DIR, env=None, verbose=False):
+    # Flush stdout here. Helps when debugging on CI.
+    sys.stdout.flush()
+
+    if start_dir != PROJECT_SRC_DIR:
+        start_dir = RepoRelative(start_dir)
+    cmd_list = command.split(" ")
+
+    if verbose:
+        print(f'CICMD({cmd_list}, env={env})')
+    subprocess.check_call(cmd_list, cwd=start_dir, env=env)
+
+# Manifest file describing out test application
+def get_android_manifest() -> str:
+    manifest = RepoRelative('cube/android/AndroidManifest.xml')
+    if not os.path.isfile(manifest):
+        print(f"Unable to find manifest for APK! {manifest}")
+        sys.exit(-1)
+    return manifest
+
+# Generate the APK from the CMake binaries
+def generate_apk(SDK_ROOT : str, CMAKE_INSTALL_DIR : str) -> str:
+    apk_dir = RepoRelative('build-android/bin')
+
+    # Delete APK directory since it could contain files from old runs
+    if os.path.isdir(apk_dir):
+        shutil.rmtree(apk_dir)
+
+    shutil.copytree(CMAKE_INSTALL_DIR, apk_dir)
+
+    android_manifest = get_android_manifest()
+
+    android_jar = f"{SDK_ROOT}/platforms/android-26/android.jar"
+    if not os.path.isfile(android_jar):
+        print(f"Unable to find {android_jar}!")
+        sys.exit(-1)
+
+    apk_name = 'VkCube'
+
+    unaligned_apk = f'{apk_dir}/{apk_name}-unaligned.apk'
+    test_apk = f'{apk_dir}/{apk_name}.apk'
+
+    # Create APK
+    RunShellCmd(f'aapt package -f -M {android_manifest} -I {android_jar} -F {unaligned_apk} {CMAKE_INSTALL_DIR}')
+
+    # Align APK
+    RunShellCmd(f'zipalign -f 4 {unaligned_apk} {test_apk}')
+
+    # Create Key (If it doesn't already exist)
+    debug_key = RepoRelative(f'{apk_dir}/debug.keystore')
+    ks_pass = 'android'
+    if not os.path.isfile(debug_key):
+        dname = 'CN=Android-Debug,O=Android,C=US'
+        RunShellCmd(f'keytool -genkey -v -keystore {debug_key} -alias androiddebugkey -storepass {ks_pass} -keypass {ks_pass} -keyalg RSA -keysize 2048 -validity 10000 -dname {dname}')
+
+    # Sign APK
+    RunShellCmd(f'apksigner sign --verbose --ks {debug_key} --ks-pass pass:{ks_pass} {test_apk}')
+
+# Android APKs can contain binaries for multiple ABIs (armeabi-v7a, arm64-v8a, x86, x86_64).
+# https://en.wikipedia.org/wiki/Apk_(file_format)#Package_contents
+#
+# As a result CMake will need to be run multiple times to create a complete test APK that can be run on any Android device.
+def main():
+    configs = ['Release', 'Debug']
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--config', type=str, choices=configs, default=configs[0])
+    parser.add_argument('--app-abi', dest='android_abi', type=str, default="arm64-v8a")
+    parser.add_argument('--app-stl', dest='android_stl', type=str, choices=["c++_static", "c++_shared"], default="c++_static")
+    parser.add_argument('--apk', action='store_true', help='Generate an APK as a post build step.')
+    parser.add_argument('--clean', action='store_true', help='Cleans CMake build artifacts')
+    args = parser.parse_args()
+
+    cmake_config = args.config
+    android_abis = args.android_abi.split(" ")
+    android_stl = args.android_stl
+    create_apk = args.apk
+    clean = args.clean
+
+    if "ANDROID_NDK_HOME" not in os.environ:
+        print("Cannot find ANDROID_NDK_HOME!")
+        sys.exit(1)
+
+    android_ndk_home = os.environ.get('ANDROID_NDK_HOME')
+    android_toolchain = f'{android_ndk_home}/build/cmake/android.toolchain.cmake'
+
+    # The only tool we require for building is CMake/Ninja
+    required_cli_tools = ['cmake', 'ninja']
+
+    # If we are building an APK we need a few more tools.
+    if create_apk:
+        if "ANDROID_SDK_ROOT" not in os.environ:
+            print("Cannot find ANDROID_SDK_ROOT!")
+            sys.exit(1)
+
+        android_sdk_root = os.environ.get('ANDROID_SDK_ROOT')
+        print(f"ANDROID_SDK_ROOT = {android_sdk_root}")
+        required_cli_tools += ['aapt', 'zipalign', 'keytool', 'apksigner']
+
+    print(f"ANDROID_NDK_HOME = {android_ndk_home}")
+    print(f"Build configured for {cmake_config} | {android_stl} | {android_abis} | APK {create_apk}")
+
+    if not os.path.isfile(android_toolchain):
+        print(f'Unable to find android.toolchain.cmake at {android_toolchain}')
+        exit(-1)
+
+    for tool in required_cli_tools:
+        path = shutil.which(tool)
+        if path is None:
+            print(f"Unable to find {tool}!")
+            exit(-1)
+
+        print(f"Using {tool} : {path}")
+
+    cmake_install_dir = RepoRelative('build-android/libs')
+
+    # Delete install directory since it could contain files from old runs
+    if os.path.isdir(cmake_install_dir):
+        print("Cleaning CMake install")
+        shutil.rmtree(cmake_install_dir)
+
+    for abi in android_abis:
+        build_dir = RepoRelative(f'build-android/cmake/{abi}')
+        lib_dir = f'lib/{abi}'
+
+        if clean:
+            print("Deleting CMakeCache.txt")
+
+            # Delete CMakeCache.txt to ensure clean builds
+            # NOTE: CMake 3.24 has --fresh which would be better to use in the future.
+            cmake_cache = f'{build_dir}/CMakeCache.txt'
+            if os.path.isfile(cmake_cache):
+                os.remove(cmake_cache)
+
+        cmake_cmd =  f'cmake -S . -B {build_dir} -G Ninja'
+
+        cmake_cmd += f' -D CMAKE_BUILD_TYPE={cmake_config}'
+        cmake_cmd += f' -D UPDATE_DEPS=ON -D UPDATE_DEPS_DIR={build_dir}'
+        cmake_cmd += f' -D CMAKE_TOOLCHAIN_FILE={android_toolchain}'
+        cmake_cmd += f' -D CMAKE_ANDROID_ARCH_ABI={abi}'
+        cmake_cmd += f' -D CMAKE_INSTALL_LIBDIR={lib_dir}'
+        cmake_cmd += f' -D CMAKE_ANDROID_STL_TYPE={android_stl}'
+
+        cmake_cmd += ' -D ANDROID_PLATFORM=26'
+        cmake_cmd += ' -D ANDROID_USE_LEGACY_TOOLCHAIN_FILE=NO'
+
+        RunShellCmd(cmake_cmd)
+
+        build_cmd = f'cmake --build {build_dir}'
+        RunShellCmd(build_cmd)
+
+        install_cmd = f'cmake --install {build_dir} --prefix {cmake_install_dir}'
+        RunShellCmd(install_cmd)
+
+    if create_apk:
+        generate_apk(SDK_ROOT = android_sdk_root, CMAKE_INSTALL_DIR = cmake_install_dir)
+
+if __name__ == '__main__':
+    main()
diff --git a/tools/Vulkan-Tools/scripts/common_codegen.py b/tools/Vulkan-Tools/scripts/common_codegen.py
new file mode 100644
index 00000000..d44cd643
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/common_codegen.py
@@ -0,0 +1,114 @@
+#!/usr/bin/python3 -i
+#
+# Copyright (c) 2015-2017, 2019-2021 The Khronos Group Inc.
+# Copyright (c) 2015-2017, 2019-2021 Valve Corporation
+# Copyright (c) 2015-2017, 2019-2021 LunarG, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Author: Mark Lobodzinski <mark@lunarg.com>
+
+import os
+import sys
+import subprocess
+
+# Copyright text prefixing all headers (list of strings).
+prefixStrings = [
+    '/*',
+    '** Copyright (c) 2015-2017, 2019-2021 The Khronos Group Inc.',
+    '** Copyright (c) 2015-2017, 2019-2021 Valve Corporation',
+    '** Copyright (c) 2015-2017, 2019-2021 LunarG, Inc.',
+    '** Copyright (c) 2015-2017, 2019-2021 Google Inc.',
+    '**',
+    '** Licensed under the Apache License, Version 2.0 (the "License");',
+    '** you may not use this file except in compliance with the License.',
+    '** You may obtain a copy of the License at',
+    '**',
+    '**     http://www.apache.org/licenses/LICENSE-2.0',
+    '**',
+    '** Unless required by applicable law or agreed to in writing, software',
+    '** distributed under the License is distributed on an "AS IS" BASIS,',
+    '** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.',
+    '** See the License for the specific language governing permissions and',
+    '** limitations under the License.',
+    '*/',
+    ''
+]
+
+
+platform_dict = {
+    'android' : 'VK_USE_PLATFORM_ANDROID_KHR',
+    'fuchsia' : 'VK_USE_PLATFORM_FUCHSIA',
+    'ggp': 'VK_USE_PLATFORM_GGP',
+    'ios' : 'VK_USE_PLATFORM_IOS_MVK',
+    'macos' : 'VK_USE_PLATFORM_MACOS_MVK',
+    'metal' : 'VK_USE_PLATFORM_METAL_EXT',
+    'vi' : 'VK_USE_PLATFORM_VI_NN',
+    'wayland' : 'VK_USE_PLATFORM_WAYLAND_KHR',
+    'win32' : 'VK_USE_PLATFORM_WIN32_KHR',
+    'xcb' : 'VK_USE_PLATFORM_XCB_KHR',
+    'xlib' : 'VK_USE_PLATFORM_XLIB_KHR',
+    'xlib_xrandr' : 'VK_USE_PLATFORM_XLIB_XRANDR_EXT',
+    'provisional' : 'VK_ENABLE_BETA_EXTENSIONS',
+    'directfb' : 'VK_USE_PLATFORM_DIRECTFB_EXT',
+    'screen' : 'VK_USE_PLATFORM_SCREEN_QNX',
+    'sci' : 'VK_USE_PLATFORM_SCI',
+    'ohos' : 'VK_USE_PLATFORM_OHOS',
+}
+
+#
+# Return appropriate feature protect string from 'platform' tag on feature
+def GetFeatureProtect(interface):
+    """Get platform protection string"""
+    platform = interface.get('platform')
+    if platform is not None:
+        return platform_dict[platform]
+
+    provisional = interface.get('provisional')
+    if provisional == 'true':
+        return platform_dict['provisional']
+
+# Returns true if we are running in GitHub actions
+# https://docs.github.com/en/actions/learn-github-actions/variables#default-environment-variables
+def IsGHA():
+    if 'GITHUB_ACTION' in os.environ:
+        return True
+    return False
+
+# Points to the directory containing the top level CMakeLists.txt
+PROJECT_SRC_DIR = os.path.abspath(os.path.join(os.path.split(os.path.abspath(__file__))[0], '..'))
+if not os.path.isfile(f'{PROJECT_SRC_DIR}/CMakeLists.txt'):
+    print(f'PROJECT_SRC_DIR invalid! {PROJECT_SRC_DIR}')
+    sys.exit(1)
+
+# helper to define paths relative to the repo root
+def RepoRelative(path):
+    return os.path.abspath(os.path.join(os.path.dirname(__file__), '..', path))
+
+# Runs a command in a directory and returns its return code.
+# Directory is project root by default, or a relative path from project root
+def RunShellCmd(command, start_dir = PROJECT_SRC_DIR, env=None, verbose=False):
+    # Flush stdout here. Helps when debugging on CI.
+    sys.stdout.flush()
+
+    if start_dir != PROJECT_SRC_DIR:
+        start_dir = RepoRelative(start_dir)
+    cmd_list = command.split(" ")
+
+    # Helps a lot when debugging CI issues
+    if IsGHA():
+        verbose = True
+
+    if verbose:
+        print(f'CICMD({cmd_list}, env={env})')
+    subprocess.check_call(cmd_list, cwd=start_dir, env=env)
\ No newline at end of file
diff --git a/tools/Vulkan-Tools/scripts/generate_source.py b/tools/Vulkan-Tools/scripts/generate_source.py
new file mode 100755
index 00000000..59314533
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/generate_source.py
@@ -0,0 +1,279 @@
+#!/usr/bin/env python3
+# Copyright (c) 2019 The Khronos Group Inc.
+# Copyright (c) 2019 Valve Corporation
+# Copyright (c) 2019 LunarG, Inc.
+# Copyright (c) 2019 Google Inc.
+# Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# Copyright (c) 2023-2023 RasterGrid Kft.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Author: Mike Schuchardt <mikes@lunarg.com>
+
+import argparse
+import filecmp
+import os
+import shutil
+import sys
+import re
+import tempfile
+import json
+import common_codegen
+
+from xml.etree import ElementTree
+
+# Because we have special logic to import the Registry from input arguments and the BaseGenerator comes from the registry, we have to delay defining it until *after*
+# the Registry has been imported. Yes this is awkward, but it was the least awkward way to make --verify work.
+generators = {}
+
+def RunGenerators(api: str, registry: str, video_registry: str, directory: str, styleFile: str, targetFilter: str, flatOutput: bool):
+
+    try:
+        common_codegen.RunShellCmd(f'clang-format --version')
+        has_clang_format = True
+    except:
+        has_clang_format = False
+    if not has_clang_format:
+        print("WARNING: Unable to find clang-format!")
+
+    # These live in the Vulkan-Docs repo, but are pulled in via the
+    # Vulkan-Headers/registry folder
+    # At runtime we inject python path to find these helper scripts
+    scripts = os.path.dirname(registry)
+    scripts_directory_path = os.path.dirname(os.path.abspath(__file__))
+    registry_headers_path = os.path.join(scripts_directory_path, scripts)
+    sys.path.insert(0, registry_headers_path)
+    try:
+        from reg import Registry
+    except:
+        print("ModuleNotFoundError: No module named 'reg'") # normal python error message
+        print(f'{registry_headers_path} is not pointing to the Vulkan-Headers registry directory.')
+        print("Inside Vulkan-Headers there is a registry/reg.py file that is used.")
+        sys.exit(1) # Return without call stack so easy to spot error
+
+    from base_generator import BaseGeneratorOptions
+    from generators.mock_icd_generator import MockICDOutputGenerator
+    from generators.vulkan_tools_helper_file_generator import HelperFileOutputGenerator
+    from generators.vulkaninfo_generator import VulkanInfoGenerator
+
+    # These set fields that are needed by both OutputGenerator and BaseGenerator,
+    # but are uniform and don't need to be set at a per-generated file level
+    from base_generator import (SetTargetApiName, SetMergedApiNames)
+    SetTargetApiName(api)
+
+    # Generated directory and dispatch table helper file name may be API specific (e.g. Vulkan SC)
+    mock_icd_generated_directory = 'icd/generated'
+    vulkaninfo_generated_directory = 'vulkaninfo/generated'
+
+    generators.update({
+        'vk_typemap_helper.h': {
+            'generator' : HelperFileOutputGenerator,
+            'genCombined': False,
+            'directory' : mock_icd_generated_directory,
+        },
+        'function_declarations.h': {
+            'generator' : MockICDOutputGenerator,
+            'genCombined': False,
+            'directory' : mock_icd_generated_directory,
+        },
+        'function_definitions.h': {
+            'generator' : MockICDOutputGenerator,
+            'genCombined': False,
+            'directory' : mock_icd_generated_directory,
+        },
+        'vulkaninfo.hpp': {
+            'generator' : VulkanInfoGenerator,
+            'genCombined': False,
+            'directory' : vulkaninfo_generated_directory,
+        },
+    })
+
+    unknownTargets = [x for x in (targetFilter if targetFilter else []) if x not in generators.keys()]
+    if unknownTargets:
+        print(f'ERROR: No generator options for unknown target(s): {", ".join(unknownTargets)}', file=sys.stderr)
+        return 1
+
+    # Filter if --target is passed in
+    targets = [x for x in generators.keys() if not targetFilter or x in targetFilter]
+
+    for index, target in enumerate(targets, start=1):
+        print(f'[{index}|{len(targets)}] Generating {target}')
+
+        # First grab a class constructor object and create an instance
+        generator = generators[target]['generator']
+        gen = generator()
+
+        # This code and the 'genCombined' generator metadata is used by downstream
+        # users to generate code with all Vulkan APIs merged into the target API variant
+        # (e.g. Vulkan SC) when needed. The constructed apiList is also used to filter
+        # out non-applicable extensions later below.
+        apiList = [api]
+        if api != 'vulkan' and generators[target]['genCombined']:
+            SetMergedApiNames('vulkan')
+            apiList.append('vulkan')
+        else:
+            SetMergedApiNames(None)
+
+        # For people who want to generate all the files in a single director
+        if flatOutput:
+            outDirectory = os.path.abspath(os.path.join(directory))
+        else:
+            outDirectory = os.path.abspath(os.path.join(directory, generators[target]['directory']))
+
+        options = BaseGeneratorOptions(
+            customFileName  = target,
+            customDirectory = outDirectory)
+
+        if not os.path.exists(outDirectory):
+            os.makedirs(outDirectory)
+
+        # Create the registry object with the specified generator and generator
+        # options. The options are set before XML loading as they may affect it.
+        reg = Registry(gen, options)
+
+        # Parse the specified registry XML into an ElementTree object
+        tree = ElementTree.parse(registry)
+
+        # Load the XML tree into the registry object
+        reg.loadElementTree(tree)
+
+        # Set the path to the video registry so that videoStd is available
+        reg.genOpts.videoXmlPath = video_registry
+
+        # Finally, use the output generator to create the requested target
+        reg.apiGen()
+
+        # Run clang-format on the file
+        if has_clang_format and styleFile:
+            common_codegen.RunShellCmd(f'clang-format -i --style=file:{styleFile} {os.path.join(outDirectory, target)}')
+
+
+def main(argv):
+
+    # files to exclude from --verify check
+    verify_exclude = ['.clang-format'] # None currently
+
+    parser = argparse.ArgumentParser(description='Generate source code for this repository')
+    parser.add_argument('registry', metavar='REGISTRY_PATH', help='path to the Vulkan-Headers registry directory')
+    parser.add_argument('--api',
+                        default='vulkan',
+                        choices=['vulkan', 'vulkansc'],
+                        help='Specify API name to generate')
+    parser.add_argument('--generated-version', help='sets the header version used to generate the repo')
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument('--target', nargs='+', help='only generate file names passed in')
+    group.add_argument('-i', '--incremental', action='store_true', help='only update repo files that change')
+    group.add_argument('-v', '--verify', action='store_true', help='verify repo files match generator output')
+    group.add_argument('-o', action='store', dest='directory', help='Create target and related files in specified directory')
+    args = parser.parse_args(argv)
+
+    repo_dir = common_codegen.RepoRelative('.')
+
+    registry = os.path.abspath(os.path.join(args.registry,  'vk.xml'))
+    video_registry = os.path.abspath(os.path.join(args.registry,  'video.xml'))
+    if not os.path.isfile(registry) and not os.path.isfile(registry):
+        registry = os.path.abspath(os.path.join(args.registry, 'Vulkan-Headers/registry/vk.xml'))
+        if not os.path.isfile(registry):
+            print(f'cannot find vk.xml in {args.registry}')
+            return -1
+        video_registry = os.path.abspath(os.path.join(args.registry,  'Vulkan-Headers/registry/video.xml'))
+        if not os.path.isfile(video_registry):
+            print(f'{video_registry} does not exist')
+            return -1
+
+    # Need pass style file incase running with --verify and it can't find the file automatically in the temp directory
+    style_file = os.path.join(repo_dir, '.clang-format')
+
+    # get directory where generators will run
+    if args.verify or args.incremental:
+        # generate in temp directory so we can compare or copy later
+        temp_obj = tempfile.TemporaryDirectory(prefix='vulkan_tools_codegen_')
+        temp_dir = temp_obj.name
+        gen_dir = temp_dir
+    elif args.directory:
+        gen_dir = args.directory
+    else:
+        # generate directly in the repo
+        gen_dir = repo_dir
+
+    RunGenerators(api=args.api,registry=registry, video_registry=video_registry, directory=gen_dir, styleFile=style_file, targetFilter=args.target, flatOutput=False)
+
+    # optional post-generation steps
+    if args.verify:
+        # compare contents of temp dir and repo
+        temp_files = {}
+        repo_files = {}
+        for details in generators.values():
+            if details['directory'] not in temp_files:
+                temp_files[details['directory']] = set()
+            temp_files[details['directory']].update(set(os.listdir(os.path.join(temp_dir, details['directory']))))
+            if details['directory'] not in repo_files:
+                repo_files[details['directory']] = set()
+            repo_files[details['directory']].update(set(os.listdir(os.path.join(repo_dir, details['directory']))) - set(verify_exclude))
+
+        # compare contents of temp dir and repo
+        files_match = True
+        for filename, details in generators.items():
+            if filename not in repo_files[details['directory']]:
+                print('ERROR: Missing repo file', filename)
+                files_match = False
+            elif filename not in temp_files[details['directory']]:
+                print('ERROR: Missing generator for', filename)
+                files_match = False
+            elif not filecmp.cmp(os.path.join(temp_dir, details['directory'], filename),
+                            os.path.join(repo_dir, details['directory'], filename),
+                            shallow=False):
+                print('ERROR: Repo files do not match generator output for', filename)
+                files_match = False
+
+        # return code for test scripts
+        if files_match:
+            print('SUCCESS: Repo files match generator output')
+            return 0
+        return 1
+
+    elif args.incremental:
+        # copy missing or differing files from temp directory to repo
+        for filename, details in generators.items():
+            temp_filename = os.path.join(temp_dir, details['directory'], filename)
+            repo_filename = os.path.join(repo_dir, details['directory'], filename)
+            if not os.path.exists(repo_filename) or \
+            not filecmp.cmp(temp_filename, repo_filename, shallow=False):
+                print('update', repo_filename)
+                shutil.copyfile(temp_filename, repo_filename)
+
+    # write out the header version used to generate the code to a checked in CMake file
+    if args.generated_version:
+        json_files = []
+        json_files.append(common_codegen.RepoRelative('icd/VkICD_mock_icd.json.in'))
+        for json_file in json_files:
+            with open(json_file) as f:
+                data = json.load(f)
+
+            data["ICD"]["api_version"] = args.generated_version
+
+            with open(json_file, mode='w', encoding='utf-8', newline='\n') as f:
+                f.write(json.dumps(data, indent=4))
+
+        # Update the CMake project version
+        with open(common_codegen.RepoRelative('CMakeLists.txt'), "r+") as f:
+            data = f.read()
+            f.seek(0)
+            f.write(re.sub("project.*VERSION.*", f"project(Vulkan-Tools VERSION {args.generated_version})", data))
+            f.truncate()
+
+    return 0
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv[1:]))
+
diff --git a/tools/Vulkan-Tools/scripts/generators/mock_icd_generator.py b/tools/Vulkan-Tools/scripts/generators/mock_icd_generator.py
new file mode 100644
index 00000000..b1d81c42
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/generators/mock_icd_generator.py
@@ -0,0 +1,1452 @@
+#!/usr/bin/python3 -i
+#
+# Copyright (c) 2015-2025 The Khronos Group Inc.
+# Copyright (c) 2015-2025 Valve Corporation
+# Copyright (c) 2015-2025 LunarG, Inc.
+# Copyright (c) 2015-2025 Google Inc.
+# Copyright (c) 2023-2025 RasterGrid Kft.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Author: Tobin Ehlis <tobine@google.com>
+#
+# This script generates a Mock ICD that intercepts almost all Vulkan
+#  functions. That layer is not intended to be useful or even compilable
+#  in its initial state. Rather it's intended to be a starting point that
+#  can be copied and customized to assist in creation of a new layer.
+
+from base_generator import BaseGenerator
+
+CUSTOM_C_INTERCEPTS = {
+'vkCreateInstance': '''
+    // TODO: If loader ver <=4 ICD must fail with VK_ERROR_INCOMPATIBLE_DRIVER for all vkCreateInstance calls with
+    //  apiVersion set to > Vulkan 1.0 because the loader is still at interface version <= 4. Otherwise, the
+    //  ICD should behave as normal.
+    if (loader_interface_version <= 4) {
+        return VK_ERROR_INCOMPATIBLE_DRIVER;
+    }
+    *pInstance = (VkInstance)CreateDispObjHandle();
+    for (auto& physical_device : physical_device_map[*pInstance])
+        physical_device = (VkPhysicalDevice)CreateDispObjHandle();
+    // TODO: If emulating specific device caps, will need to add intelligence here
+    return VK_SUCCESS;
+''',
+'vkDestroyInstance': '''
+    if (instance) {
+        for (const auto physical_device : physical_device_map.at(instance)) {
+            display_map.erase(physical_device);
+            DestroyDispObjHandle((void*)physical_device);
+        }
+        physical_device_map.erase(instance);
+        DestroyDispObjHandle((void*)instance);
+    }
+''',
+'vkAllocateCommandBuffers': '''
+    unique_lock_t lock(global_lock);
+    for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; ++i) {
+        pCommandBuffers[i] = (VkCommandBuffer)CreateDispObjHandle();
+        command_pool_buffer_map[pAllocateInfo->commandPool].push_back(pCommandBuffers[i]);
+    }
+    return VK_SUCCESS;
+''',
+'vkFreeCommandBuffers': '''
+    unique_lock_t lock(global_lock);
+    for (auto i = 0u; i < commandBufferCount; ++i) {
+        if (!pCommandBuffers[i]) {
+            continue;
+        }
+
+        for (auto& pair : command_pool_buffer_map) {
+            auto& cbs = pair.second;
+            auto it = std::find(cbs.begin(), cbs.end(), pCommandBuffers[i]);
+            if (it != cbs.end()) {
+                cbs.erase(it);
+            }
+        }
+
+        DestroyDispObjHandle((void*) pCommandBuffers[i]);
+    }
+''',
+'vkCreateCommandPool': '''
+    unique_lock_t lock(global_lock);
+    *pCommandPool = (VkCommandPool)global_unique_handle++;
+    command_pool_map[device].insert(*pCommandPool);
+    return VK_SUCCESS;
+''',
+'vkDestroyCommandPool': '''
+    // destroy command buffers for this pool
+    unique_lock_t lock(global_lock);
+    auto it = command_pool_buffer_map.find(commandPool);
+    if (it != command_pool_buffer_map.end()) {
+        for (auto& cb : it->second) {
+            DestroyDispObjHandle((void*) cb);
+        }
+        command_pool_buffer_map.erase(it);
+    }
+    command_pool_map[device].erase(commandPool);
+''',
+'vkEnumeratePhysicalDevices': '''
+    VkResult result_code = VK_SUCCESS;
+    if (pPhysicalDevices) {
+        const auto return_count = (std::min)(*pPhysicalDeviceCount, icd_physical_device_count);
+        for (uint32_t i = 0; i < return_count; ++i) pPhysicalDevices[i] = physical_device_map.at(instance)[i];
+        if (return_count < icd_physical_device_count) result_code = VK_INCOMPLETE;
+        *pPhysicalDeviceCount = return_count;
+    } else {
+        *pPhysicalDeviceCount = icd_physical_device_count;
+    }
+    return result_code;
+''',
+'vkCreateDevice': '''
+    *pDevice = (VkDevice)CreateDispObjHandle();
+    // TODO: If emulating specific device caps, will need to add intelligence here
+    return VK_SUCCESS;
+''',
+'vkDestroyDevice': '''
+    unique_lock_t lock(global_lock);
+    // First destroy sub-device objects
+    // Destroy Queues
+    for (auto queue_family_map_pair : queue_map[device]) {
+        for (auto index_queue_pair : queue_map[device][queue_family_map_pair.first]) {
+            DestroyDispObjHandle((void*)index_queue_pair.second);
+        }
+    }
+
+    for (auto& cp : command_pool_map[device]) {
+        for (auto& cb : command_pool_buffer_map[cp]) {
+            DestroyDispObjHandle((void*) cb);
+        }
+        command_pool_buffer_map.erase(cp);
+    }
+    command_pool_map[device].clear();
+
+    queue_map.erase(device);
+    buffer_map.erase(device);
+    image_memory_size_map.erase(device);
+    // Now destroy device
+    DestroyDispObjHandle((void*)device);
+    // TODO: If emulating specific device caps, will need to add intelligence here
+''',
+'vkGetDeviceQueue': '''
+    unique_lock_t lock(global_lock);
+    auto queue = queue_map[device][queueFamilyIndex][queueIndex];
+    if (queue) {
+        *pQueue = queue;
+    } else {
+        *pQueue = queue_map[device][queueFamilyIndex][queueIndex] = (VkQueue)CreateDispObjHandle();
+    }
+    // TODO: If emulating specific device caps, will need to add intelligence here
+    return;
+''',
+'vkGetDeviceQueue2': '''
+    GetDeviceQueue(device, pQueueInfo->queueFamilyIndex, pQueueInfo->queueIndex, pQueue);
+    // TODO: Add further support for GetDeviceQueue2 features
+''',
+'vkEnumerateInstanceLayerProperties': '''
+    return VK_SUCCESS;
+''',
+'vkEnumerateInstanceVersion': '''
+    *pApiVersion = VK_HEADER_VERSION_COMPLETE;
+    return VK_SUCCESS;
+''',
+'vkEnumerateDeviceLayerProperties': '''
+    return VK_SUCCESS;
+''',
+'vkEnumerateInstanceExtensionProperties': '''
+    // If requesting number of extensions, return that
+    if (!pLayerName) {
+        if (!pProperties) {
+            *pPropertyCount = (uint32_t)instance_extension_map.size();
+        } else {
+            uint32_t i = 0;
+            for (const auto &name_ver_pair : instance_extension_map) {
+                if (i == *pPropertyCount) {
+                    break;
+                }
+                std::strncpy(pProperties[i].extensionName, name_ver_pair.first.c_str(), sizeof(pProperties[i].extensionName));
+                pProperties[i].extensionName[sizeof(pProperties[i].extensionName) - 1] = 0;
+                pProperties[i].specVersion = name_ver_pair.second;
+                ++i;
+            }
+            if (i != instance_extension_map.size()) {
+                return VK_INCOMPLETE;
+            }
+        }
+    }
+    // If requesting extension properties, fill in data struct for number of extensions
+    return VK_SUCCESS;
+''',
+'vkEnumerateDeviceExtensionProperties': '''
+    // If requesting number of extensions, return that
+    if (!pLayerName) {
+        if (!pProperties) {
+            *pPropertyCount = (uint32_t)device_extension_map.size();
+        } else {
+            uint32_t i = 0;
+            for (const auto &name_ver_pair : device_extension_map) {
+                if (i == *pPropertyCount) {
+                    break;
+                }
+                std::strncpy(pProperties[i].extensionName, name_ver_pair.first.c_str(), sizeof(pProperties[i].extensionName));
+                pProperties[i].extensionName[sizeof(pProperties[i].extensionName) - 1] = 0;
+                pProperties[i].specVersion = name_ver_pair.second;
+                ++i;
+            }
+            *pPropertyCount = i;
+            if (i != device_extension_map.size()) {
+                return VK_INCOMPLETE;
+            }
+        }
+    }
+    // If requesting extension properties, fill in data struct for number of extensions
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceSurfacePresentModesKHR': '''
+    // Currently always say that all present modes are supported
+    if (!pPresentModes) {
+        *pPresentModeCount = 6;
+    } else {
+        if (*pPresentModeCount >= 6) pPresentModes[5] = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR;
+        if (*pPresentModeCount >= 5) pPresentModes[4] = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR;
+        if (*pPresentModeCount >= 4) pPresentModes[3] = VK_PRESENT_MODE_FIFO_RELAXED_KHR;
+        if (*pPresentModeCount >= 3) pPresentModes[2] = VK_PRESENT_MODE_FIFO_KHR;
+        if (*pPresentModeCount >= 2) pPresentModes[1] = VK_PRESENT_MODE_MAILBOX_KHR;
+        if (*pPresentModeCount >= 1) pPresentModes[0] = VK_PRESENT_MODE_IMMEDIATE_KHR;
+        *pPresentModeCount = *pPresentModeCount < 6 ? *pPresentModeCount : 6;
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceSurfaceFormatsKHR': '''
+    // Currently always say that RGBA8 & BGRA8 are supported
+    if (!pSurfaceFormats) {
+        *pSurfaceFormatCount = 2;
+    } else {
+        if (*pSurfaceFormatCount >= 2) {
+            pSurfaceFormats[1].format = VK_FORMAT_R8G8B8A8_UNORM;
+            pSurfaceFormats[1].colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
+        }
+        if (*pSurfaceFormatCount >= 1) {
+            pSurfaceFormats[0].format = VK_FORMAT_B8G8R8A8_UNORM;
+            pSurfaceFormats[0].colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
+        }
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceSurfaceFormats2KHR': '''
+    // Currently always say that RGBA8 & BGRA8 are supported
+    if (!pSurfaceFormats) {
+        *pSurfaceFormatCount = 2;
+    } else {
+        if (*pSurfaceFormatCount >= 2) {
+            pSurfaceFormats[1].pNext = nullptr;
+            pSurfaceFormats[1].surfaceFormat.format = VK_FORMAT_R8G8B8A8_UNORM;
+            pSurfaceFormats[1].surfaceFormat.colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
+        }
+        if (*pSurfaceFormatCount >= 1) {
+            pSurfaceFormats[1].pNext = nullptr;
+            pSurfaceFormats[0].surfaceFormat.format = VK_FORMAT_B8G8R8A8_UNORM;
+            pSurfaceFormats[0].surfaceFormat.colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
+        }
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceSurfaceSupportKHR': '''
+    // Currently say that all surface/queue combos are supported
+    *pSupported = VK_TRUE;
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceSurfaceCapabilitiesKHR': '''
+    // In general just say max supported is available for requested surface
+    pSurfaceCapabilities->minImageCount = 1;
+    pSurfaceCapabilities->maxImageCount = 0;
+    pSurfaceCapabilities->currentExtent.width = 0xFFFFFFFF;
+    pSurfaceCapabilities->currentExtent.height = 0xFFFFFFFF;
+    pSurfaceCapabilities->minImageExtent.width = 1;
+    pSurfaceCapabilities->minImageExtent.height = 1;
+    pSurfaceCapabilities->maxImageExtent.width = 0xFFFF;
+    pSurfaceCapabilities->maxImageExtent.height = 0xFFFF;
+    pSurfaceCapabilities->maxImageArrayLayers = 128;
+    pSurfaceCapabilities->supportedTransforms = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR |
+                                                VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR |
+                                                VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR |
+                                                VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR |
+                                                VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR |
+                                                VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR |
+                                                VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR |
+                                                VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR |
+                                                VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR;
+    pSurfaceCapabilities->currentTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
+    pSurfaceCapabilities->supportedCompositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR |
+                                                    VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR |
+                                                    VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR |
+                                                    VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
+    pSurfaceCapabilities->supportedUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
+                                                VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+                                                VK_IMAGE_USAGE_SAMPLED_BIT |
+                                                VK_IMAGE_USAGE_STORAGE_BIT |
+                                                VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
+                                                VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
+                                                VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT |
+                                                VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceSurfaceCapabilities2KHR': '''
+    GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, pSurfaceInfo->surface, &pSurfaceCapabilities->surfaceCapabilities);
+
+    auto *present_mode_compatibility = lvl_find_mod_in_chain<VkSurfacePresentModeCompatibilityEXT>(pSurfaceCapabilities->pNext);
+    if (present_mode_compatibility) {
+        if (!present_mode_compatibility->pPresentModes) {
+            present_mode_compatibility->presentModeCount = 3;
+        } else {
+            // arbitrary
+            present_mode_compatibility->pPresentModes[0] = VK_PRESENT_MODE_IMMEDIATE_KHR;
+            present_mode_compatibility->pPresentModes[1] = VK_PRESENT_MODE_FIFO_KHR;
+            present_mode_compatibility->pPresentModes[2] = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR;
+        }
+    }
+    return VK_SUCCESS;
+''',
+'vkGetInstanceProcAddr': '''
+    if (!negotiate_loader_icd_interface_called) {
+        loader_interface_version = 0;
+    }
+    const auto &item = name_to_funcptr_map.find(pName);
+    if (item != name_to_funcptr_map.end()) {
+        return reinterpret_cast<PFN_vkVoidFunction>(item->second);
+    }
+    // Mock should intercept all functions so if we get here just return null
+    return nullptr;
+''',
+'vkGetDeviceProcAddr': '''
+    return GetInstanceProcAddr(nullptr, pName);
+''',
+'vkGetPhysicalDeviceMemoryProperties': '''
+    pMemoryProperties->memoryTypeCount = 6;
+    // Host visible Coherent
+    pMemoryProperties->memoryTypes[0].propertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+    pMemoryProperties->memoryTypes[0].heapIndex = 0;
+    // Host visible Cached
+    pMemoryProperties->memoryTypes[1].propertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
+    pMemoryProperties->memoryTypes[1].heapIndex = 0;
+    // Device local and Host visible
+    pMemoryProperties->memoryTypes[2].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+    pMemoryProperties->memoryTypes[2].heapIndex = 1;
+    // Device local lazily
+    pMemoryProperties->memoryTypes[3].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT;
+    pMemoryProperties->memoryTypes[3].heapIndex = 1;
+    // Device local protected
+    pMemoryProperties->memoryTypes[4].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_PROTECTED_BIT;
+    pMemoryProperties->memoryTypes[4].heapIndex = 1;
+    // Device local only
+    pMemoryProperties->memoryTypes[5].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+    pMemoryProperties->memoryTypes[5].heapIndex = 1;
+    pMemoryProperties->memoryHeapCount = 2;
+    pMemoryProperties->memoryHeaps[0].flags = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT;
+    pMemoryProperties->memoryHeaps[0].size = 8000000000;
+    pMemoryProperties->memoryHeaps[1].flags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT;
+    pMemoryProperties->memoryHeaps[1].size = 8000000000;
+''',
+'vkGetPhysicalDeviceMemoryProperties2KHR': '''
+    GetPhysicalDeviceMemoryProperties(physicalDevice, &pMemoryProperties->memoryProperties);
+''',
+'vkGetPhysicalDeviceQueueFamilyProperties': '''
+    if (pQueueFamilyProperties) {
+        std::vector<VkQueueFamilyProperties2KHR> props2(*pQueueFamilyPropertyCount, {
+            VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR});
+        GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, props2.data());
+        for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; ++i) {
+            pQueueFamilyProperties[i] = props2[i].queueFamilyProperties;
+        }
+    } else {
+        GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, nullptr);
+    }
+''',
+'vkGetPhysicalDeviceQueueFamilyProperties2KHR': '''
+    if (pQueueFamilyProperties) {
+        if (*pQueueFamilyPropertyCount >= 1) {
+            auto props = &pQueueFamilyProperties[0].queueFamilyProperties;
+            props->queueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT
+                                | VK_QUEUE_SPARSE_BINDING_BIT | VK_QUEUE_PROTECTED_BIT;
+            props->queueCount = 1;
+            props->timestampValidBits = 16;
+            props->minImageTransferGranularity = {1,1,1};
+        }
+        if (*pQueueFamilyPropertyCount >= 2) {
+            auto props = &pQueueFamilyProperties[1].queueFamilyProperties;
+            props->queueFlags = VK_QUEUE_TRANSFER_BIT | VK_QUEUE_PROTECTED_BIT | VK_QUEUE_VIDEO_DECODE_BIT_KHR;
+            props->queueCount = 1;
+            props->timestampValidBits = 16;
+            props->minImageTransferGranularity = {1,1,1};
+
+            auto status_query_props = lvl_find_mod_in_chain<VkQueueFamilyQueryResultStatusPropertiesKHR>(pQueueFamilyProperties[1].pNext);
+            if (status_query_props) {
+                status_query_props->queryResultStatusSupport = VK_TRUE;
+            }
+            auto video_props = lvl_find_mod_in_chain<VkQueueFamilyVideoPropertiesKHR>(pQueueFamilyProperties[1].pNext);
+            if (video_props) {
+                video_props->videoCodecOperations = VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR
+                                                  | VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR
+                                                  | VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR;
+            }
+        }
+        if (*pQueueFamilyPropertyCount >= 3) {
+            auto props = &pQueueFamilyProperties[2].queueFamilyProperties;
+            props->queueFlags = VK_QUEUE_TRANSFER_BIT | VK_QUEUE_PROTECTED_BIT | VK_QUEUE_VIDEO_ENCODE_BIT_KHR;
+            props->queueCount = 1;
+            props->timestampValidBits = 16;
+            props->minImageTransferGranularity = {1,1,1};
+
+            auto status_query_props = lvl_find_mod_in_chain<VkQueueFamilyQueryResultStatusPropertiesKHR>(pQueueFamilyProperties[2].pNext);
+            if (status_query_props) {
+                status_query_props->queryResultStatusSupport = VK_TRUE;
+            }
+            auto video_props = lvl_find_mod_in_chain<VkQueueFamilyVideoPropertiesKHR>(pQueueFamilyProperties[2].pNext);
+            if (video_props) {
+                video_props->videoCodecOperations = VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR
+                                                  | VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR
+                                                  | VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR;
+            }
+        }
+        if (*pQueueFamilyPropertyCount > 3) {
+            *pQueueFamilyPropertyCount = 3;
+        }
+    } else {
+        *pQueueFamilyPropertyCount = 3;
+    }
+''',
+'vkGetPhysicalDeviceFeatures': '''
+    uint32_t num_bools = sizeof(VkPhysicalDeviceFeatures) / sizeof(VkBool32);
+    VkBool32 *bool_array = &pFeatures->robustBufferAccess;
+    SetBoolArrayTrue(bool_array, num_bools);
+''',
+'vkGetPhysicalDeviceFeatures2KHR': '''
+    GetPhysicalDeviceFeatures(physicalDevice, &pFeatures->features);
+    uint32_t num_bools = 0; // Count number of VkBool32s in extension structs
+    VkBool32* feat_bools = nullptr;
+    auto vk_1_1_features = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan11Features>(pFeatures->pNext);
+    if (vk_1_1_features) {
+        vk_1_1_features->protectedMemory = VK_TRUE;
+    }
+    auto vk_1_3_features = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan13Features>(pFeatures->pNext);
+    if (vk_1_3_features) {
+        vk_1_3_features->synchronization2 = VK_TRUE;
+    }
+    auto prot_features = lvl_find_mod_in_chain<VkPhysicalDeviceProtectedMemoryFeatures>(pFeatures->pNext);
+    if (prot_features) {
+        prot_features->protectedMemory = VK_TRUE;
+    }
+    auto sync2_features = lvl_find_mod_in_chain<VkPhysicalDeviceSynchronization2FeaturesKHR>(pFeatures->pNext);
+    if (sync2_features) {
+        sync2_features->synchronization2 = VK_TRUE;
+    }
+    auto video_maintenance1_features = lvl_find_mod_in_chain<VkPhysicalDeviceVideoMaintenance1FeaturesKHR>(pFeatures->pNext);
+    if (video_maintenance1_features) {
+        video_maintenance1_features->videoMaintenance1 = VK_TRUE;
+    }
+    const auto *desc_idx_features = lvl_find_in_chain<VkPhysicalDeviceDescriptorIndexingFeaturesEXT>(pFeatures->pNext);
+    if (desc_idx_features) {
+        const auto bool_size = sizeof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT) - offsetof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT, shaderInputAttachmentArrayDynamicIndexing);
+        num_bools = bool_size/sizeof(VkBool32);
+        feat_bools = (VkBool32*)&desc_idx_features->shaderInputAttachmentArrayDynamicIndexing;
+        SetBoolArrayTrue(feat_bools, num_bools);
+    }
+    const auto *blendop_features = lvl_find_in_chain<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(pFeatures->pNext);
+    if (blendop_features) {
+        const auto bool_size = sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT) - offsetof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, advancedBlendCoherentOperations);
+        num_bools = bool_size/sizeof(VkBool32);
+        feat_bools = (VkBool32*)&blendop_features->advancedBlendCoherentOperations;
+        SetBoolArrayTrue(feat_bools, num_bools);
+    }
+    const auto *host_image_copy_features = lvl_find_in_chain<VkPhysicalDeviceHostImageCopyFeaturesEXT>(pFeatures->pNext);
+    if (host_image_copy_features) {
+       feat_bools = (VkBool32*)&host_image_copy_features->hostImageCopy;
+       SetBoolArrayTrue(feat_bools, 1);
+    }
+''',
+'vkGetPhysicalDeviceFormatProperties': '''
+    if (VK_FORMAT_UNDEFINED == format) {
+        *pFormatProperties = { 0x0, 0x0, 0x0 };
+    } else {
+        // Default to a color format, skip DS bit
+        *pFormatProperties = { 0x00FFFDFF, 0x00FFFDFF, 0x00FFFDFF };
+        switch (format) {
+            case VK_FORMAT_D16_UNORM:
+            case VK_FORMAT_X8_D24_UNORM_PACK32:
+            case VK_FORMAT_D32_SFLOAT:
+            case VK_FORMAT_S8_UINT:
+            case VK_FORMAT_D16_UNORM_S8_UINT:
+            case VK_FORMAT_D24_UNORM_S8_UINT:
+            case VK_FORMAT_D32_SFLOAT_S8_UINT:
+                // Don't set color bits for DS formats
+                *pFormatProperties = { 0x00FFFE7F, 0x00FFFE7F, 0x00FFFE7F };
+                break;
+            case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
+            case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
+            case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
+            case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
+            case VK_FORMAT_G8_B8R8_2PLANE_444_UNORM:
+                // Set decode/encode bits for these formats
+                *pFormatProperties = { 0x1EFFFDFF, 0x1EFFFDFF, 0x00FFFDFF };
+                break;
+            default:
+                break;
+        }
+    }
+''',
+'vkGetPhysicalDeviceFormatProperties2KHR': '''
+    GetPhysicalDeviceFormatProperties(physicalDevice, format, &pFormatProperties->formatProperties);
+    VkFormatProperties3KHR *props_3 = lvl_find_mod_in_chain<VkFormatProperties3KHR>(pFormatProperties->pNext);
+    if (props_3) {
+        props_3->linearTilingFeatures = pFormatProperties->formatProperties.linearTilingFeatures;
+        props_3->optimalTilingFeatures = pFormatProperties->formatProperties.optimalTilingFeatures;
+        props_3->bufferFeatures = pFormatProperties->formatProperties.bufferFeatures;
+        props_3->optimalTilingFeatures |= VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT;
+    }
+''',
+'vkGetPhysicalDeviceImageFormatProperties': '''
+    // A hardcoded unsupported format
+    if (format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32) {
+        return VK_ERROR_FORMAT_NOT_SUPPORTED;
+    }
+
+    // TODO: Just hard-coding some values for now
+    // TODO: If tiling is linear, limit the mips, levels, & sample count
+    if (VK_IMAGE_TILING_LINEAR == tiling) {
+        *pImageFormatProperties = { { 4096, 4096, 256 }, 1, 1, VK_SAMPLE_COUNT_1_BIT, 4294967296 };
+    } else {
+        // We hard-code support for all sample counts except 64 bits.
+        *pImageFormatProperties = { { 4096, 4096, 256 }, 12, 256, 0x7F & ~VK_SAMPLE_COUNT_64_BIT, 4294967296 };
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceImageFormatProperties2KHR': '''
+    auto *external_image_prop = lvl_find_mod_in_chain<VkExternalImageFormatProperties>(pImageFormatProperties->pNext);
+    auto *external_image_format = lvl_find_in_chain<VkPhysicalDeviceExternalImageFormatInfo>(pImageFormatInfo->pNext);
+    if (external_image_prop && external_image_format) {
+        external_image_prop->externalMemoryProperties.externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
+        external_image_prop->externalMemoryProperties.compatibleHandleTypes = external_image_format->handleType;
+    }
+
+    GetPhysicalDeviceImageFormatProperties(physicalDevice, pImageFormatInfo->format, pImageFormatInfo->type, pImageFormatInfo->tiling, pImageFormatInfo->usage, pImageFormatInfo->flags, &pImageFormatProperties->imageFormatProperties);
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceSparseImageFormatProperties': '''
+    if (!pProperties) {
+        *pPropertyCount = 1;
+    } else {
+        // arbitrary
+        pProperties->imageGranularity = {4, 4, 4};
+        pProperties->flags = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT;
+        switch (format) {
+            case VK_FORMAT_D16_UNORM:
+            case VK_FORMAT_D32_SFLOAT:
+                pProperties->aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
+                break;
+            case VK_FORMAT_S8_UINT:
+                pProperties->aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
+                break;
+            case VK_FORMAT_X8_D24_UNORM_PACK32:
+            case VK_FORMAT_D16_UNORM_S8_UINT:
+            case VK_FORMAT_D24_UNORM_S8_UINT:
+            case VK_FORMAT_D32_SFLOAT_S8_UINT:
+                pProperties->aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
+                break;
+            default:
+                pProperties->aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+                break;
+        }
+    }
+''',
+'vkGetPhysicalDeviceSparseImageFormatProperties2KHR': '''
+    if (pPropertyCount && pProperties) {
+        GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, pFormatInfo->format, pFormatInfo->type, pFormatInfo->samples, pFormatInfo->usage, pFormatInfo->tiling, pPropertyCount, &pProperties->properties);
+    } else {
+        GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, pFormatInfo->format, pFormatInfo->type, pFormatInfo->samples, pFormatInfo->usage, pFormatInfo->tiling, pPropertyCount, nullptr);
+    }
+''',
+'vkGetPhysicalDeviceProperties': '''
+    pProperties->apiVersion = VK_HEADER_VERSION_COMPLETE;
+    pProperties->driverVersion = 1;
+    pProperties->vendorID = 0xba5eba11;
+    pProperties->deviceID = 0xf005ba11;
+    pProperties->deviceType = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU;
+    //std::string devName = "Vulkan Mock Device";
+    strcpy(pProperties->deviceName, "Vulkan Mock Device");
+    pProperties->pipelineCacheUUID[0] = 18;
+    pProperties->limits = SetLimits(&pProperties->limits);
+    pProperties->sparseProperties = { VK_TRUE, VK_TRUE, VK_TRUE, VK_TRUE, VK_TRUE };
+''',
+'vkGetPhysicalDeviceProperties2KHR': '''
+    // The only value that need to be set are those the Profile layer can't set
+    // see https://github.com/KhronosGroup/Vulkan-Profiles/issues/352
+    // All values set are arbitrary
+    GetPhysicalDeviceProperties(physicalDevice, &pProperties->properties);
+
+    auto *props_11 = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan11Properties>(pProperties->pNext);
+    if (props_11) {
+        props_11->protectedNoFault = VK_FALSE;
+    }
+
+    auto *props_12 = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan12Properties>(pProperties->pNext);
+    if (props_12) {
+        props_12->denormBehaviorIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL;
+        props_12->roundingModeIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL;
+    }
+
+    auto *props_13 = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan13Properties>(pProperties->pNext);
+    if (props_13) {
+        props_13->storageTexelBufferOffsetSingleTexelAlignment = VK_TRUE;
+        props_13->uniformTexelBufferOffsetSingleTexelAlignment = VK_TRUE;
+        props_13->storageTexelBufferOffsetAlignmentBytes = 16;
+        props_13->uniformTexelBufferOffsetAlignmentBytes = 16;
+    }
+
+    auto *protected_memory_props = lvl_find_mod_in_chain<VkPhysicalDeviceProtectedMemoryProperties>(pProperties->pNext);
+    if (protected_memory_props) {
+        protected_memory_props->protectedNoFault = VK_FALSE;
+    }
+
+    auto *float_controls_props = lvl_find_mod_in_chain<VkPhysicalDeviceFloatControlsProperties>(pProperties->pNext);
+    if (float_controls_props) {
+        float_controls_props->denormBehaviorIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL;
+        float_controls_props->roundingModeIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL;
+    }
+
+    auto *conservative_raster_props = lvl_find_mod_in_chain<VkPhysicalDeviceConservativeRasterizationPropertiesEXT>(pProperties->pNext);
+    if (conservative_raster_props) {
+        conservative_raster_props->primitiveOverestimationSize = 0.00195313f;
+        conservative_raster_props->conservativePointAndLineRasterization = VK_TRUE;
+        conservative_raster_props->degenerateTrianglesRasterized = VK_TRUE;
+        conservative_raster_props->degenerateLinesRasterized = VK_TRUE;
+    }
+
+    auto *rt_pipeline_props = lvl_find_mod_in_chain<VkPhysicalDeviceRayTracingPipelinePropertiesKHR>(pProperties->pNext);
+    if (rt_pipeline_props) {
+        rt_pipeline_props->shaderGroupHandleSize = 32;
+        rt_pipeline_props->shaderGroupBaseAlignment = 64;
+        rt_pipeline_props->shaderGroupHandleCaptureReplaySize = 32;
+    }
+
+    auto *rt_pipeline_nv_props = lvl_find_mod_in_chain<VkPhysicalDeviceRayTracingPropertiesNV>(pProperties->pNext);
+    if (rt_pipeline_nv_props) {
+        rt_pipeline_nv_props->shaderGroupHandleSize = 32;
+        rt_pipeline_nv_props->shaderGroupBaseAlignment = 64;
+    }
+
+    auto *texel_buffer_props = lvl_find_mod_in_chain<VkPhysicalDeviceTexelBufferAlignmentProperties>(pProperties->pNext);
+    if (texel_buffer_props) {
+        texel_buffer_props->storageTexelBufferOffsetSingleTexelAlignment = VK_TRUE;
+        texel_buffer_props->uniformTexelBufferOffsetSingleTexelAlignment = VK_TRUE;
+        texel_buffer_props->storageTexelBufferOffsetAlignmentBytes = 16;
+        texel_buffer_props->uniformTexelBufferOffsetAlignmentBytes = 16;
+    }
+
+    auto *descriptor_buffer_props = lvl_find_mod_in_chain<VkPhysicalDeviceDescriptorBufferPropertiesEXT>(pProperties->pNext);
+    if (descriptor_buffer_props) {
+        descriptor_buffer_props->combinedImageSamplerDescriptorSingleArray = VK_TRUE;
+        descriptor_buffer_props->bufferlessPushDescriptors = VK_TRUE;
+        descriptor_buffer_props->allowSamplerImageViewPostSubmitCreation = VK_TRUE;
+        descriptor_buffer_props->descriptorBufferOffsetAlignment = 4;
+    }
+
+    auto *mesh_shader_props = lvl_find_mod_in_chain<VkPhysicalDeviceMeshShaderPropertiesEXT>(pProperties->pNext);
+    if (mesh_shader_props) {
+        mesh_shader_props->meshOutputPerVertexGranularity = 32;
+        mesh_shader_props->meshOutputPerPrimitiveGranularity = 32;
+        mesh_shader_props->prefersLocalInvocationVertexOutput = VK_TRUE;
+        mesh_shader_props->prefersLocalInvocationPrimitiveOutput = VK_TRUE;
+        mesh_shader_props->prefersCompactVertexOutput = VK_TRUE;
+        mesh_shader_props->prefersCompactPrimitiveOutput = VK_TRUE;
+    }
+
+    auto *fragment_density_map2_props = lvl_find_mod_in_chain<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT>(pProperties->pNext);
+    if (fragment_density_map2_props) {
+        fragment_density_map2_props->subsampledLoads = VK_FALSE;
+        fragment_density_map2_props->subsampledCoarseReconstructionEarlyAccess = VK_FALSE;
+        fragment_density_map2_props->maxSubsampledArrayLayers = 2;
+        fragment_density_map2_props->maxDescriptorSetSubsampledSamplers = 1;
+    }
+
+    auto *maintenance3_props = lvl_find_mod_in_chain<VkPhysicalDeviceMaintenance3Properties>(pProperties->pNext);
+    if (maintenance3_props) {
+        maintenance3_props->maxMemoryAllocationSize = 1073741824;
+        maintenance3_props->maxPerSetDescriptors = 1024;
+    }
+
+    const uint32_t num_copy_layouts = 5;
+    const VkImageLayout HostCopyLayouts[]{
+       VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+       VK_IMAGE_LAYOUT_GENERAL,
+       VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
+       VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL,
+       VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL,
+    };
+
+    auto *host_image_copy_props = lvl_find_mod_in_chain<VkPhysicalDeviceHostImageCopyPropertiesEXT>(pProperties->pNext);
+    if (host_image_copy_props){
+        if (host_image_copy_props->pCopyDstLayouts == nullptr) host_image_copy_props->copyDstLayoutCount = num_copy_layouts;
+        else {
+            uint32_t num_layouts = (std::min)(host_image_copy_props->copyDstLayoutCount, num_copy_layouts);
+            for (uint32_t i = 0; i < num_layouts; i++) {
+                host_image_copy_props->pCopyDstLayouts[i] = HostCopyLayouts[i];
+            }
+        }
+        if (host_image_copy_props->pCopySrcLayouts == nullptr) host_image_copy_props->copySrcLayoutCount = num_copy_layouts;
+        else {
+            uint32_t num_layouts = (std::min)(host_image_copy_props->copySrcLayoutCount, num_copy_layouts);
+             for (uint32_t i = 0; i < num_layouts; i++) {
+                host_image_copy_props->pCopySrcLayouts[i] = HostCopyLayouts[i];
+            }
+        }
+    }
+
+    auto *driver_properties = lvl_find_mod_in_chain<VkPhysicalDeviceDriverProperties>(pProperties->pNext);
+    if (driver_properties) {
+        std::strncpy(driver_properties->driverName, "Vulkan Mock Device", VK_MAX_DRIVER_NAME_SIZE);
+#if defined(GIT_BRANCH_NAME) && defined(GIT_TAG_INFO)
+        std::strncpy(driver_properties->driverInfo, "Branch: " GIT_BRANCH_NAME " Tag Info: " GIT_TAG_INFO, VK_MAX_DRIVER_INFO_SIZE);
+#else
+        std::strncpy(driver_properties->driverInfo, "Branch: --unknown-- Tag Info: --unknown--", VK_MAX_DRIVER_INFO_SIZE);
+#endif
+    }
+
+    auto *layered_properties = lvl_find_mod_in_chain<VkPhysicalDeviceLayeredApiPropertiesListKHR>(pProperties->pNext);
+    if (layered_properties) {
+        layered_properties->layeredApiCount = 1;
+        if (layered_properties->pLayeredApis) {
+            layered_properties->pLayeredApis[0] = VkPhysicalDeviceLayeredApiPropertiesKHR{
+                VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR,
+                nullptr,
+                0xba5eba11,
+                0xf005ba11,
+                VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR
+            };
+            std::strncpy(layered_properties->pLayeredApis[0].deviceName, "Fake Driver", VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
+        }
+    }
+''',
+'vkGetPhysicalDeviceExternalSemaphoreProperties':'''
+    // Hard code support for all handle types and features
+    pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0x1F;
+    pExternalSemaphoreProperties->compatibleHandleTypes = 0x1F;
+    pExternalSemaphoreProperties->externalSemaphoreFeatures = 0x3;
+''',
+'vkGetPhysicalDeviceExternalSemaphorePropertiesKHR':'''
+    GetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
+''',
+'vkGetPhysicalDeviceExternalFenceProperties':'''
+    // Hard-code support for all handle types and features
+    pExternalFenceProperties->exportFromImportedHandleTypes = 0xF;
+    pExternalFenceProperties->compatibleHandleTypes = 0xF;
+    pExternalFenceProperties->externalFenceFeatures = 0x3;
+''',
+'vkGetPhysicalDeviceExternalFencePropertiesKHR':'''
+    GetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+''',
+'vkGetPhysicalDeviceExternalBufferProperties':'''
+    constexpr VkExternalMemoryHandleTypeFlags supported_flags = 0x1FF;
+    if (pExternalBufferInfo->handleType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID) {
+        // Can't have dedicated memory with AHB
+        pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
+        pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes = pExternalBufferInfo->handleType;
+        pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = pExternalBufferInfo->handleType;
+    } else if (pExternalBufferInfo->handleType & supported_flags) {
+        pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures = 0x7;
+        pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes = supported_flags;
+        pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = supported_flags;
+    } else {
+        pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures = 0;
+        pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes = 0;
+        // According to spec, handle type is always compatible with itself. Even if export/import
+        // not supported, it's important to properly implement self-compatibility property since
+        // application's control flow can rely on this.
+        pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = pExternalBufferInfo->handleType;
+    }
+''',
+'vkGetPhysicalDeviceExternalBufferPropertiesKHR':'''
+    GetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+''',
+'vkGetBufferMemoryRequirements': '''
+    // TODO: Just hard-coding reqs for now
+    pMemoryRequirements->size = 4096;
+    pMemoryRequirements->alignment = 1;
+    pMemoryRequirements->memoryTypeBits = 0xFFFF;
+    // Return a better size based on the buffer size from the create info.
+    unique_lock_t lock(global_lock);
+    auto d_iter = buffer_map.find(device);
+    if (d_iter != buffer_map.end()) {
+        auto iter = d_iter->second.find(buffer);
+        if (iter != d_iter->second.end()) {
+            pMemoryRequirements->size = ((iter->second.size + 4095) / 4096) * 4096;
+        }
+    }
+''',
+'vkGetBufferMemoryRequirements2KHR': '''
+    GetBufferMemoryRequirements(device, pInfo->buffer, &pMemoryRequirements->memoryRequirements);
+''',
+'vkGetDeviceBufferMemoryRequirements': '''
+    // TODO: Just hard-coding reqs for now
+    pMemoryRequirements->memoryRequirements.alignment = 1;
+    pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF;
+
+    // Return a size based on the buffer size from the create info.
+    pMemoryRequirements->memoryRequirements.size = ((pInfo->pCreateInfo->size + 4095) / 4096) * 4096;
+''',
+'vkGetDeviceBufferMemoryRequirementsKHR': '''
+    GetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements);
+''',
+'vkGetImageMemoryRequirements': '''
+    pMemoryRequirements->size = 0;
+    pMemoryRequirements->alignment = 1;
+
+    unique_lock_t lock(global_lock);
+    auto d_iter = image_memory_size_map.find(device);
+    if(d_iter != image_memory_size_map.end()){
+        auto iter = d_iter->second.find(image);
+        if (iter != d_iter->second.end()) {
+            pMemoryRequirements->size = iter->second;
+        }
+    }
+    // Here we hard-code that the memory type at index 3 doesn't support this image.
+    pMemoryRequirements->memoryTypeBits = 0xFFFF & ~(0x1 << 3);
+''',
+'vkGetImageMemoryRequirements2KHR': '''
+    GetImageMemoryRequirements(device, pInfo->image, &pMemoryRequirements->memoryRequirements);
+''',
+'vkGetDeviceImageMemoryRequirements': '''
+    pMemoryRequirements->memoryRequirements.size = GetImageSizeFromCreateInfo(pInfo->pCreateInfo);
+    pMemoryRequirements->memoryRequirements.alignment = 1;
+    // Here we hard-code that the memory type at index 3 doesn't support this image.
+    pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF & ~(0x1 << 3);
+''',
+'vkGetDeviceImageMemoryRequirementsKHR': '''
+    GetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements);
+''',
+'vkMapMemory': '''
+    unique_lock_t lock(global_lock);
+    if (VK_WHOLE_SIZE == size) {
+        if (allocated_memory_size_map.count(memory) != 0)
+            size = allocated_memory_size_map[memory] - offset;
+        else
+            size = 0x10000;
+    }
+    void* map_addr = malloc((size_t)size);
+    mapped_memory_map[memory].push_back(map_addr);
+    *ppData = map_addr;
+    return VK_SUCCESS;
+''',
+'vkMapMemory2KHR': '''
+    return MapMemory(device, pMemoryMapInfo->memory, pMemoryMapInfo->offset, pMemoryMapInfo->size, pMemoryMapInfo->flags, ppData);
+''',
+'vkUnmapMemory': '''
+    unique_lock_t lock(global_lock);
+    for (auto map_addr : mapped_memory_map[memory]) {
+        free(map_addr);
+    }
+    mapped_memory_map.erase(memory);
+''',
+'vkUnmapMemory2KHR': '''
+    UnmapMemory(device, pMemoryUnmapInfo->memory);
+    return VK_SUCCESS;
+''',
+'vkGetImageSubresourceLayout': '''
+    // Need safe values. Callers are computing memory offsets from pLayout, with no return code to flag failure.
+    *pLayout = VkSubresourceLayout(); // Default constructor zero values.
+''',
+'vkCreateSwapchainKHR': '''
+    unique_lock_t lock(global_lock);
+    *pSwapchain = (VkSwapchainKHR)global_unique_handle++;
+    for(uint32_t i = 0; i < icd_swapchain_image_count; ++i){
+        swapchain_image_map[*pSwapchain][i] = (VkImage)global_unique_handle++;
+    }
+    return VK_SUCCESS;
+''',
+'vkDestroySwapchainKHR': '''
+    unique_lock_t lock(global_lock);
+    swapchain_image_map.clear();
+''',
+'vkGetSwapchainImagesKHR': '''
+    if (!pSwapchainImages) {
+        *pSwapchainImageCount = icd_swapchain_image_count;
+    } else {
+        unique_lock_t lock(global_lock);
+        for (uint32_t img_i = 0; img_i < (std::min)(*pSwapchainImageCount, icd_swapchain_image_count); ++img_i){
+            pSwapchainImages[img_i] = swapchain_image_map.at(swapchain)[img_i];
+        }
+
+        if (*pSwapchainImageCount < icd_swapchain_image_count) return VK_INCOMPLETE;
+        else if (*pSwapchainImageCount > icd_swapchain_image_count) *pSwapchainImageCount = icd_swapchain_image_count;
+    }
+    return VK_SUCCESS;
+''',
+'vkAcquireNextImageKHR': '''
+    *pImageIndex = 0;
+    return VK_SUCCESS;
+''',
+'vkAcquireNextImage2KHR': '''
+    *pImageIndex = 0;
+    return VK_SUCCESS;
+''',
+'vkCreateBuffer': '''
+    unique_lock_t lock(global_lock);
+    *pBuffer = (VkBuffer)global_unique_handle++;
+     buffer_map[device][*pBuffer] = {
+         pCreateInfo->size,
+         current_available_address
+     };
+     current_available_address += pCreateInfo->size;
+     // Always align to next 64-bit pointer
+     const uint64_t alignment = current_available_address % 64;
+     if (alignment != 0) {
+         current_available_address += (64 - alignment);
+     }
+    return VK_SUCCESS;
+''',
+'vkDestroyBuffer': '''
+    unique_lock_t lock(global_lock);
+    buffer_map[device].erase(buffer);
+''',
+'vkCreateImage': '''
+    unique_lock_t lock(global_lock);
+    *pImage = (VkImage)global_unique_handle++;
+    image_memory_size_map[device][*pImage] = GetImageSizeFromCreateInfo(pCreateInfo);
+    return VK_SUCCESS;
+''',
+'vkDestroyImage': '''
+    unique_lock_t lock(global_lock);
+    image_memory_size_map[device].erase(image);
+''',
+'vkEnumeratePhysicalDeviceGroupsKHR': '''
+    if (!pPhysicalDeviceGroupProperties) {
+        *pPhysicalDeviceGroupCount = 1;
+    } else {
+        // arbitrary
+        pPhysicalDeviceGroupProperties->physicalDeviceCount = 1;
+        pPhysicalDeviceGroupProperties->physicalDevices[0] = physical_device_map.at(instance)[0];
+        pPhysicalDeviceGroupProperties->subsetAllocation = VK_FALSE;
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceMultisamplePropertiesEXT': '''
+    if (pMultisampleProperties) {
+        // arbitrary
+        pMultisampleProperties->maxSampleLocationGridSize = {32, 32};
+    }
+''',
+'vkGetPhysicalDeviceFragmentShadingRatesKHR': '''
+    if (!pFragmentShadingRates) {
+        *pFragmentShadingRateCount = 1;
+    } else {
+        // arbitrary
+        pFragmentShadingRates->sampleCounts = VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT;
+        pFragmentShadingRates->fragmentSize = {8, 8};
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceCalibrateableTimeDomainsEXT': '''
+    if (!pTimeDomains) {
+        *pTimeDomainCount = 1;
+    } else {
+        // arbitrary
+        *pTimeDomains = VK_TIME_DOMAIN_DEVICE_EXT;
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceCalibrateableTimeDomainsKHR': '''
+    if (!pTimeDomains) {
+        *pTimeDomainCount = 1;
+    } else {
+        // arbitrary
+        *pTimeDomains = VK_TIME_DOMAIN_DEVICE_KHR;
+    }
+    return VK_SUCCESS;
+''',
+'vkGetFenceWin32HandleKHR': '''
+    *pHandle = (HANDLE)0x12345678;
+    return VK_SUCCESS;
+''',
+'vkGetFenceFdKHR': '''
+    *pFd = 0x42;
+    return VK_SUCCESS;
+''',
+'vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR': '''
+    if (!pCounters) {
+        *pCounterCount = 3;
+    } else {
+        if (*pCounterCount == 0){
+            return VK_INCOMPLETE;
+        }
+        // arbitrary
+        pCounters[0].unit = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR;
+        pCounters[0].scope = VK_QUERY_SCOPE_COMMAND_BUFFER_KHR;
+        pCounters[0].storage = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR;
+        pCounters[0].uuid[0] = 0x01;
+        if (*pCounterCount == 1){
+            return VK_INCOMPLETE;
+        }
+        pCounters[1].unit = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR;
+        pCounters[1].scope = VK_QUERY_SCOPE_RENDER_PASS_KHR;
+        pCounters[1].storage = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR;
+        pCounters[1].uuid[0] = 0x02;
+        if (*pCounterCount == 2){
+            return VK_INCOMPLETE;
+        }
+        pCounters[2].unit = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR;
+        pCounters[2].scope = VK_QUERY_SCOPE_COMMAND_KHR;
+        pCounters[2].storage = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR;
+        pCounters[2].uuid[0] = 0x03;
+        *pCounterCount = 3;
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR': '''
+    if (pNumPasses) {
+        // arbitrary
+        *pNumPasses = 1;
+    }
+''',
+'vkGetShaderModuleIdentifierEXT': '''
+    if (pIdentifier) {
+        // arbitrary
+        pIdentifier->identifierSize = 1;
+        pIdentifier->identifier[0] = 0x01;
+    }
+''',
+'vkGetImageSparseMemoryRequirements': '''
+    if (!pSparseMemoryRequirements) {
+        *pSparseMemoryRequirementCount = 1;
+    } else {
+        // arbitrary
+        pSparseMemoryRequirements->imageMipTailFirstLod = 0;
+        pSparseMemoryRequirements->imageMipTailSize = 8;
+        pSparseMemoryRequirements->imageMipTailOffset = 0;
+        pSparseMemoryRequirements->imageMipTailStride = 4;
+        pSparseMemoryRequirements->formatProperties.imageGranularity = {4, 4, 4};
+        pSparseMemoryRequirements->formatProperties.flags = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT;
+        // Would need to track the VkImage to know format for better value here
+        pSparseMemoryRequirements->formatProperties.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT;
+    }
+
+''',
+'vkGetImageSparseMemoryRequirements2KHR': '''
+    if (pSparseMemoryRequirementCount && pSparseMemoryRequirements) {
+        GetImageSparseMemoryRequirements(device, pInfo->image, pSparseMemoryRequirementCount, &pSparseMemoryRequirements->memoryRequirements);
+    } else {
+        GetImageSparseMemoryRequirements(device, pInfo->image, pSparseMemoryRequirementCount, nullptr);
+    }
+''',
+'vkGetBufferDeviceAddress': '''
+    VkDeviceAddress address = 0;
+    auto d_iter = buffer_map.find(device);
+    if (d_iter != buffer_map.end()) {
+        auto iter = d_iter->second.find(pInfo->buffer);
+        if (iter != d_iter->second.end()) {
+            address = iter->second.address;
+        }
+    }
+    return address;
+''',
+'vkGetBufferDeviceAddressKHR': '''
+    return GetBufferDeviceAddress(device, pInfo);
+''',
+'vkGetBufferDeviceAddressEXT': '''
+    return GetBufferDeviceAddress(device, pInfo);
+''',
+'vkGetDescriptorSetLayoutSizeEXT': '''
+    // Need to give something non-zero
+    *pLayoutSizeInBytes = 4;
+''',
+'vkGetAccelerationStructureBuildSizesKHR': '''
+    // arbitrary
+    pSizeInfo->accelerationStructureSize = 4;
+    pSizeInfo->updateScratchSize = 4;
+    pSizeInfo->buildScratchSize = 4;
+''',
+'vkGetAccelerationStructureMemoryRequirementsNV': '''
+    // arbitrary
+    pMemoryRequirements->memoryRequirements.size = 4096;
+    pMemoryRequirements->memoryRequirements.alignment = 1;
+    pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF;
+''',
+'vkGetAccelerationStructureDeviceAddressKHR': '''
+    // arbitrary - need to be aligned to 256 bytes
+    return 0x262144;
+''',
+'vkGetVideoSessionMemoryRequirementsKHR': '''
+    if (!pMemoryRequirements) {
+        *pMemoryRequirementsCount = 1;
+    } else {
+        // arbitrary
+        pMemoryRequirements[0].memoryBindIndex = 0;
+        pMemoryRequirements[0].memoryRequirements.size = 4096;
+        pMemoryRequirements[0].memoryRequirements.alignment = 1;
+        pMemoryRequirements[0].memoryRequirements.memoryTypeBits = 0xFFFF;
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR': '''
+    if (!pProperties) {
+        *pPropertyCount = 2;
+    } else {
+        // arbitrary
+        pProperties[0].MSize = 16;
+        pProperties[0].NSize = 16;
+        pProperties[0].KSize = 16;
+        pProperties[0].AType = VK_COMPONENT_TYPE_UINT32_KHR;
+        pProperties[0].BType = VK_COMPONENT_TYPE_UINT32_KHR;
+        pProperties[0].CType = VK_COMPONENT_TYPE_UINT32_KHR;
+        pProperties[0].ResultType = VK_COMPONENT_TYPE_UINT32_KHR;
+        pProperties[0].saturatingAccumulation = VK_FALSE;
+        pProperties[0].scope = VK_SCOPE_SUBGROUP_KHR;
+
+        pProperties[1] = pProperties[0];
+        pProperties[1].scope = VK_SCOPE_DEVICE_KHR;
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceVideoCapabilitiesKHR': '''
+    return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR;
+''',
+'vkGetPhysicalDeviceVideoFormatPropertiesKHR': '''
+    return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR;
+''',
+'vkGetDescriptorSetLayoutSupport':'''
+    if (pSupport) {
+        pSupport->supported = VK_TRUE;
+    }
+''',
+'vkGetDescriptorSetLayoutSupportKHR':'''
+    GetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
+''',
+'vkGetRenderAreaGranularity': '''
+    pGranularity->width = 1;
+    pGranularity->height = 1;
+''',
+'vkGetMemoryFdKHR': '''
+    *pFd = 1;
+    return VK_SUCCESS;
+''',
+'vkGetMemoryHostPointerPropertiesEXT': '''
+    pMemoryHostPointerProperties->memoryTypeBits = 1 << 5; // DEVICE_LOCAL only type
+    return VK_SUCCESS;
+''',
+'vkGetAndroidHardwareBufferPropertiesANDROID': '''
+    pProperties->allocationSize = 65536;
+    pProperties->memoryTypeBits = 1 << 5; // DEVICE_LOCAL only type
+
+    auto *format_prop = lvl_find_mod_in_chain<VkAndroidHardwareBufferFormatPropertiesANDROID>(pProperties->pNext);
+    if (format_prop) {
+        // Likley using this format
+        format_prop->format = VK_FORMAT_R8G8B8A8_UNORM;
+        format_prop->externalFormat = 37;
+    }
+
+    auto *format_resolve_prop = lvl_find_mod_in_chain<VkAndroidHardwareBufferFormatResolvePropertiesANDROID>(pProperties->pNext);
+    if (format_resolve_prop) {
+        format_resolve_prop->colorAttachmentFormat = VK_FORMAT_R8G8B8A8_UNORM;
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceDisplayPropertiesKHR': '''
+    if (!pProperties) {
+        *pPropertyCount = 1;
+    } else {
+        unique_lock_t lock(global_lock);
+        pProperties[0].display = (VkDisplayKHR)global_unique_handle++;
+        display_map[physicalDevice].insert(pProperties[0].display);
+    }
+    return VK_SUCCESS;
+''',
+'vkRegisterDisplayEventEXT': '''
+    unique_lock_t lock(global_lock);
+    *pFence = (VkFence)global_unique_handle++;
+    return VK_SUCCESS;
+''',
+'vkQueueSubmit': '''
+    // Special way to cause DEVICE_LOST
+    // Picked VkExportFenceCreateInfo because needed some struct that wouldn't get cleared by validation Safe Struct
+    // ... TODO - It would be MUCH nicer to have a layer or other setting control when this occured
+    // For now this is used to allow Validation Layers test reacting to device losts
+    if (submitCount > 0 && pSubmits) {
+        auto pNext = reinterpret_cast<const VkBaseInStructure *>(pSubmits[0].pNext);
+        if (pNext && pNext->sType == VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO && pNext->pNext == nullptr) {
+            return VK_ERROR_DEVICE_LOST;
+        }
+    }
+    return VK_SUCCESS;
+''',
+'vkGetMemoryWin32HandlePropertiesKHR': '''
+    pMemoryWin32HandleProperties->memoryTypeBits = 0xFFFF;
+    return VK_SUCCESS;
+''',
+'vkCreatePipelineBinariesKHR': '''
+    unique_lock_t lock(global_lock);
+    if (pBinaries->pPipelineBinaries != nullptr)
+    {
+        for (uint32_t i = 0; i < pBinaries->pipelineBinaryCount; ++i) {
+            pBinaries->pPipelineBinaries[i] = (VkPipelineBinaryKHR)global_unique_handle++;
+        }
+    }
+    else
+    {
+       // In this case, we need to return a return count, let's set it to 3
+       pBinaries->pipelineBinaryCount = 3;
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPipelineKeyKHR': '''
+    if (pPipelineKey != nullptr)
+    {
+        pPipelineKey->keySize = 16;
+        std::memset(pPipelineKey->key, 0x12, pPipelineKey->keySize);
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPipelineBinaryDataKHR': '''
+    static uint32_t fake_size = 64;
+    if (pPipelineBinaryDataSize != nullptr)
+    {
+        if (pPipelineBinaryData == nullptr)
+        {
+            *pPipelineBinaryDataSize = fake_size;
+        }
+        else
+        {
+            std::memset(pPipelineBinaryData, 0xABCD, fake_size);
+        }
+    }
+    return VK_SUCCESS;
+'''
+}
+
+# MockICDOutputGenerator
+# Generates a mock vulkan ICD.
+#  This is intended to be a minimal replacement for a vulkan device in order
+#  to enable testing of Vulkan applications and layers
+#
+class MockICDOutputGenerator(BaseGenerator):
+    def __init__(self):
+        BaseGenerator.__init__(self)
+
+        # Ignore extensions that ICDs should not implement or are not safe to report
+        self.ignore_exts = ['VK_EXT_validation_cache', 'VK_KHR_portability_subset']
+
+        # Dispatchable handles
+        self.dispatchable_handles = ['VkInstance','VkPhysicalDevice', 'VkDevice', 'VkCommandBuffer', 'VkQueue']
+
+    def generate_function_declarations(self, out):
+
+        out.append('#include <stdint.h>\n')
+        out.append('#include <cstring>\n')
+        out.append('#include <string>\n')
+        out.append('#include <unordered_map>\n')
+        out.append('#include <vulkan/vulkan.h>\n')
+        out.append('\n')
+        out.append('namespace vkmock {\n')
+        out.append('// Map of instance extension name to version\n')
+        out.append('static const std::unordered_map<std::string, uint32_t> instance_extension_map = {\n')
+        for ext in [x for x in self.vk.extensions.values() if x.instance and x.name not in self.ignore_exts]:
+            if ext.protect:
+                out.append(f'#ifdef {ext.protect}\n')
+            out.append(f'    {{"{ext.name}", {ext.specVersion}}},\n')
+            if ext.protect:
+                out.append('#endif\n')
+        out.append('};\n')
+        out.append('// Map of device extension name to version\n')
+        out.append('static const std::unordered_map<std::string, uint32_t> device_extension_map = {\n')
+        for ext in [x for x in self.vk.extensions.values() if x.device and x.name not in self.ignore_exts]:
+            if ext.protect:
+                out.append(f'#ifdef {ext.protect}\n')
+            out.append(f'    {{"{ext.name}", {ext.specVersion}}},\n')
+            if ext.protect:
+                out.append('#endif\n')
+        out.append('};\n')
+
+        current_protect = None
+        for name, cmd in self.vk.commands.items():
+            prepend_newline = '\n'
+            if cmd.protect != current_protect:
+                if current_protect is not None:
+                    out.append(f'#endif /* {current_protect} */\n')
+                    prepend_newline = ''
+                if current_protect is not None and cmd.protect is not None:
+                    out.append('\n')
+                if cmd.protect is not None:
+                    out.append(f'#ifdef {cmd.protect}\n')
+                current_protect = cmd.protect
+            out.append(f'{prepend_newline}static {cmd.cPrototype.replace(name, name[2:])}\n')
+        if current_protect is not None:
+            out.append('#endif\n')
+
+            # record intercepted procedures
+        out.append('// Map of all APIs to be intercepted by this layer\n')
+        out.append('static const std::unordered_map<std::string, void*> name_to_funcptr_map = {\n')
+        for name, cmd in self.vk.commands.items():
+            if cmd.protect:
+                out.append(f'#ifdef {cmd.protect}\n')
+            out.append(f'    {{"{name}", (void*){name[2:]}}},\n')
+            if cmd.protect:
+                out.append('#endif\n')
+        out.append('};\n')
+
+    def generate_function_definitions(self, out):
+        out.append('#include "mock_icd.h"\n')
+        out.append('#include "function_declarations.h"\n')
+        out.append('namespace vkmock {\n')
+
+        manual_functions = [
+            # Include functions here to be intercepted w/ manually implemented function bodies
+            'vkGetDeviceProcAddr',
+            'vkGetInstanceProcAddr',
+            'vkCreateDevice',
+            'vkDestroyDevice',
+            'vkCreateInstance',
+            'vkDestroyInstance',
+            'vkFreeCommandBuffers',
+            'vkAllocateCommandBuffers',
+            'vkDestroyCommandPool',
+            #'vkCreateDebugReportCallbackEXT',
+            #'vkDestroyDebugReportCallbackEXT',
+            'vkEnumerateInstanceLayerProperties',
+            'vkEnumerateInstanceVersion',
+            'vkEnumerateInstanceExtensionProperties',
+            'vkEnumerateDeviceLayerProperties',
+            'vkEnumerateDeviceExtensionProperties',
+            'vkGetPipelineKeyKHR',
+            'vkGetPipelineBinaryDataKHR',
+        ]
+
+        current_protect = None
+        for name, cmd in self.vk.commands.items():
+            if cmd.protect != current_protect:
+                if current_protect is not None:
+                    out.append(f'#endif /* {current_protect} */\n')
+                if current_protect is not None and cmd.protect is not None:
+                    out.append('\n')
+                if cmd.protect is not None:
+                    out.append(f'#ifdef {cmd.protect}\n')
+                current_protect = cmd.protect
+
+            if name in manual_functions:
+                if name not in CUSTOM_C_INTERCEPTS:
+                    out.append(f'static {cmd.cPrototype.replace(name, name[2:])}\n')
+                    out.append('// TODO: Implement custom intercept body\n')
+                else:
+                    out.append(f'static {cmd.cPrototype[:-1].replace(name, name[2:])}\n')
+                    out.append(f'{{{CUSTOM_C_INTERCEPTS[name]}}}\n')
+                continue
+
+            out.append(f'static {cmd.cPrototype[:-1].replace(name, name[2:])}\n')
+            if name in CUSTOM_C_INTERCEPTS:
+                out.append(f'{{{CUSTOM_C_INTERCEPTS[name]}}}\n')
+                continue
+
+            # if the name w/ KHR postfix is in the CUSTOM_C_INTERCEPTS
+            # Call the KHR custom version instead of generating separate code
+            khr_name = name + "KHR"
+            if khr_name in CUSTOM_C_INTERCEPTS:
+                return_string = ''
+                if cmd.returnType != 'void':
+                    return_string = 'return '
+
+                param_names = []
+                for param in cmd.params:
+                    param_names.append(param.name)
+                out.append(f'{{\n    {return_string}{khr_name[2:]}({", ".join(param_names)});\n}}\n')
+                continue
+            out.append('{\n')
+
+            # GET THE TYPE OF FUNCTION
+            if any(name.startswith(ftxt) for ftxt in ('vkCreate', 'vkAllocate')):
+                # Get last param
+                last_param = cmd.params[-1]
+                lp_txt = last_param.name
+                lp_len = None
+                if last_param.length is not None:
+                    lp_len = last_param.length
+                    lp_len = lp_len.replace('::', '->')
+                lp_type = last_param.type
+                handle_type = 'dispatchable'
+                allocator_txt = 'CreateDispObjHandle()'
+                if lp_type not in self.dispatchable_handles:
+                    handle_type = 'non-' + handle_type
+                    allocator_txt = 'global_unique_handle++'
+                # Need to lock in both cases
+                out.append('    unique_lock_t lock(global_lock);\n')
+                if lp_len is not None:
+                    #print("%s last params (%s) has len %s" % (handle_type, lp_txt, lp_len))
+                    out.append(f'    for (uint32_t i = 0; i < {lp_len}; ++i) {{\n')
+                    out.append(f'        {lp_txt}[i] = ({lp_type}){allocator_txt};\n')
+                    out.append('    }\n')
+                else:
+                    #print("Single %s last param is '%s' w/ type '%s'" % (handle_type, lp_txt, lp_type))
+                    if 'AllocateMemory' in name:
+                        # Store allocation size in case it's mapped
+                        out.append('    allocated_memory_size_map[(VkDeviceMemory)global_unique_handle] = pAllocateInfo->allocationSize;\n')
+                    out.append(f'    *{lp_txt} = ({lp_type}){allocator_txt};\n')
+            elif True in [ftxt in name for ftxt in ['Destroy', 'Free']]:
+                out.append('//Destroy object\n')
+                if 'FreeMemory' in name:
+                    # If the memory is mapped, unmap it
+                    out.append('    UnmapMemory(device, memory);\n')
+                    # Remove from allocation map
+                    out.append('    unique_lock_t lock(global_lock);\n')
+                    out.append('    allocated_memory_size_map.erase(memory);\n')
+            else:
+                out.append('//Not a CREATE or DESTROY function\n')
+
+            # Return result variable, if any.
+            if cmd.returnType != 'void':
+                if name == 'vkGetEventStatus':
+                    out.append('    return VK_EVENT_SET;\n')
+                else:
+                    out.append('    return VK_SUCCESS;\n')
+            out.append('}\n')
+        if current_protect is not None:
+            out.append('#endif\n')
+
+    def generate(self):
+        out = []
+        out.append('''/*
+** Copyright (c) 2015-2025 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+#pragma once
+''')
+
+        if self.filename == "function_declarations.h":
+            self.generate_function_declarations(out)
+        else:
+            self.generate_function_definitions(out)
+
+        out.append('\n')
+        out.append('} // namespace vkmock\n')
+        out.append('\n')
+        self.write(''.join(out))
diff --git a/tools/Vulkan-Tools/scripts/generators/vulkan_tools_helper_file_generator.py b/tools/Vulkan-Tools/scripts/generators/vulkan_tools_helper_file_generator.py
new file mode 100644
index 00000000..baf3e816
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/generators/vulkan_tools_helper_file_generator.py
@@ -0,0 +1,163 @@
+#!/usr/bin/python3 -i
+#
+# Copyright (c) 2015-2021 The Khronos Group Inc.
+# Copyright (c) 2015-2021 Valve Corporation
+# Copyright (c) 2015-2021 LunarG, Inc.
+# Copyright (c) 2015-2021 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Author: Mark Lobodzinski <mark@lunarg.com>
+# Author: Tobin Ehlis <tobine@google.com>
+# Author: John Zulauf <jzulauf@lunarg.com>
+
+from base_generator import BaseGenerator
+
+# HelperFileOutputGenerator - subclass of OutputGenerator. Outputs Vulkan helper files
+class HelperFileOutputGenerator(BaseGenerator):
+    def __init__(self):
+        BaseGenerator.__init__(self)
+
+
+    def generate(self):
+        out = []
+
+        # File Comment
+        out.append('// *** THIS FILE IS GENERATED - DO NOT EDIT ***\n')
+        out.append('// See vulkan_tools_helper_file_generator.py for modifications\n')
+
+        # Copyright Notice
+        out.append('''
+
+/***************************************************************************
+ *
+ * Copyright (c) 2015-2017 The Khronos Group Inc.
+ * Copyright (c) 2015-2017 Valve Corporation
+ * Copyright (c) 2015-2017 LunarG, Inc.
+ * Copyright (c) 2015-2017 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Mark Lobodzinski <mark@lunarg.com>
+ * Author: Courtney Goeltzenleuchter <courtneygo@google.com>
+ * Author: Tobin Ehlis <tobine@google.com>
+ * Author: Chris Forbes <chrisforbes@google.com>
+ * Author: John Zulauf<jzulauf@lunarg.com>
+ *
+ ****************************************************************************/
+''')
+
+        # Generate header
+        out.append('''
+#pragma once
+#include <vulkan/vulkan.h>
+
+// These empty generic templates are specialized for each type with sType
+// members and for each sType -- providing a two way map between structure
+// types and sTypes
+
+template <VkStructureType id> struct LvlSTypeMap {};
+template <typename T> struct LvlTypeMap {};
+
+''')
+
+        # Generate the specializations for each type and stype
+        for struct in self.vk.structs.values():
+            if struct.sType is None:
+                continue
+
+            if struct.protect is not None:
+                out.append(f'#ifdef {struct.protect}\n')
+
+            out.append(f'// Map type {struct.name} to id {struct.sType}\n')
+            out.append(f'template <> struct LvlTypeMap<{struct.name}> {{\n')
+            out.append(f'    static const VkStructureType kSType = {struct.sType};\n')
+            out.append('};\n\n')
+
+
+            out.append(f'template <> struct LvlSTypeMap<{struct.sType}> {{\n')
+            out.append(f'    typedef {struct.name} Type;\n')
+            out.append('};\n\n')
+
+            if struct.protect is not None:
+                out.append(f'#endif // {struct.protect}\n')
+
+ # Define the utilities (here so any renaming stays consistent), if this grows large, refactor to a fixed .h file
+
+        out.append('''// Header "base class" for pNext chain traversal
+struct LvlGenericHeader {
+   VkStructureType sType;
+   const LvlGenericHeader *pNext;
+};
+struct LvlGenericModHeader {
+   VkStructureType sType;
+   LvlGenericModHeader *pNext;
+};
+
+// Find an entry of the given type in the pNext chain
+template <typename T> const T *lvl_find_in_chain(const void *next) {
+    const LvlGenericHeader *current = reinterpret_cast<const LvlGenericHeader *>(next);
+    const T *found = nullptr;
+    while (current) {
+        if (LvlTypeMap<T>::kSType == current->sType) {
+            found = reinterpret_cast<const T*>(current);
+            current = nullptr;
+        } else {
+            current = current->pNext;
+        }
+    }
+    return found;
+}
+// Find an entry of the given type in the pNext chain
+template <typename T> T *lvl_find_mod_in_chain(void *next) {
+    LvlGenericModHeader *current = reinterpret_cast<LvlGenericModHeader *>(next);
+    T *found = nullptr;
+    while (current) {
+        if (LvlTypeMap<T>::kSType == current->sType) {
+            found = reinterpret_cast<T*>(current);
+            current = nullptr;
+        } else {
+            current = current->pNext;
+        }
+    }
+    return found;
+}
+
+// Init the header of an sType struct with pNext
+template <typename T> T lvl_init_struct(void *p_next) {
+    T out = {};
+    out.sType = LvlTypeMap<T>::kSType;
+    out.pNext = p_next;
+    return out;
+}
+
+// Init the header of an sType struct
+template <typename T> T lvl_init_struct() {
+    T out = {};
+    out.sType = LvlTypeMap<T>::kSType;
+    return out;
+}
+''')
+
+        self.write(''.join(out))
+
diff --git a/tools/Vulkan-Tools/scripts/generators/vulkaninfo_generator.py b/tools/Vulkan-Tools/scripts/generators/vulkaninfo_generator.py
new file mode 100644
index 00000000..472459ac
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/generators/vulkaninfo_generator.py
@@ -0,0 +1,1165 @@
+#!/usr/bin/python3
+#
+# Copyright (c) 2019-2026 Valve Corporation
+# Copyright (c) 2019-2026 LunarG, Inc.
+# Copyright (c) 2019-2022 Google Inc.
+# Copyright (c) 2023-2024 RasterGrid Kft.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Author: Charles Giessen <charles@lunarg.com>
+
+from base_generator import BaseGenerator
+
+from collections import OrderedDict
+
+LICENSE_HEADER = '''
+/*
+ * Copyright (c) 2019-2026 The Khronos Group Inc.
+ * Copyright (c) 2019-2026 Valve Corporation
+ * Copyright (c) 2019-2026 LunarG, Inc.
+ * Copyright (c) 2023-2024 RasterGrid Kft.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Charles Giessen <charles@lunarg.com>
+ *
+ */
+
+/*
+ * This file is generated from the Khronos Vulkan XML API Registry.
+ */
+'''
+
+CUSTOM_FORMATTERS = r'''
+template <typename T>
+std::string to_hex_str(const T i) {
+    std::stringstream stream;
+    stream << "0x" << std::setfill('0') << std::setw(sizeof(T)) << std::hex << i;
+    return stream.str();
+}
+
+template <typename T>
+std::string to_hex_str(Printer &p, const T i) {
+    if (p.Type() == OutputType::json)
+        return std::to_string(i);
+    else if (p.Type() == OutputType::vkconfig_output)
+        return std::string("\"") + to_hex_str(i) + std::string("\"");
+    else
+        return to_hex_str(i);
+}
+
+'''
+
+
+# used in the .cpp code
+STRUCTURES_TO_GEN = ['VkExtent3D', 'VkExtent2D', 'VkPhysicalDeviceLimits', 'VkPhysicalDeviceFeatures', 'VkPhysicalDeviceSparseProperties',
+                     'VkSurfaceCapabilitiesKHR', 'VkSurfaceFormatKHR', 'VkLayerProperties', 'VkPhysicalDeviceToolProperties', 'VkFormatProperties',
+                     'VkSurfacePresentScalingCapabilitiesKHR', 'VkSurfacePresentModeCompatibilityKHR', 'VkPhysicalDeviceHostImageCopyProperties',
+                     'VkVideoProfileInfoKHR', 'VkVideoCapabilitiesKHR', 'VkVideoFormatPropertiesKHR', 'VkCooperativeMatrixPropertiesKHR',
+                     'VkPhysicalDeviceFragmentShadingRateKHR', 'VkMultisamplePropertiesEXT',
+                     'VkDisplayPropertiesKHR', 'VkDisplayPlanePropertiesKHR', 'VkDisplayPlaneCapabilitiesKHR', 'VkDisplayModePropertiesKHR',
+                     'VkDisplayModeParametersKHR']
+
+ENUMS_TO_GEN = ['VkResult', 'VkFormat', 'VkPresentModeKHR',
+                'VkPhysicalDeviceType', 'VkImageTiling', 'VkTimeDomainKHR']
+FLAGS_TO_GEN = ['VkSurfaceTransformFlagsKHR', 'VkCompositeAlphaFlagsKHR', 'VkSurfaceCounterFlagsEXT', 'VkQueueFlags',
+                'VkDeviceGroupPresentModeFlagsKHR', 'VkFormatFeatureFlags', 'VkFormatFeatureFlags2', 'VkMemoryPropertyFlags', 'VkMemoryHeapFlags']
+FLAG_STRINGS_TO_GEN = ['VkQueueFlags']
+
+STRUCT_SHORT_VERSIONS_TO_GEN = ['VkExtent3D', 'VkExtent2D']
+
+STRUCT_COMPARISONS_TO_GEN = ['VkSurfaceFormatKHR', 'VkSurfaceFormat2KHR', 'VkSurfaceCapabilitiesKHR',
+                             'VkSurfaceCapabilities2KHR', 'VkSurfaceCapabilities2EXT']
+# don't generate these structures
+STRUCT_BLACKLIST = ['VkVideoProfileListInfoKHR', 'VkDrmFormatModifierPropertiesListEXT', 'VkDrmFormatModifierPropertiesEXT', 'VkDrmFormatModifierPropertiesList2EXT']
+# These structures are only used in version 1.1, otherwise they are included in the promoted structs
+STRUCT_1_1_LIST = ['VkPhysicalDeviceProtectedMemoryFeatures', 'VkPhysicalDeviceShaderDrawParametersFeatures', 'VkPhysicalDeviceSubgroupProperties', 'VkPhysicalDeviceProtectedMemoryProperties']
+
+# generate these structures such that they only print when not in json mode (as json wants them separate)
+PORTABILITY_STRUCTS = ['VkPhysicalDevicePortabilitySubsetFeaturesKHR', 'VkPhysicalDevicePortabilitySubsetPropertiesKHR']
+
+# iostream or custom outputter handles these types
+PREDEFINED_TYPES = ['char', 'VkBool32', 'uint32_t', 'uint8_t', 'int32_t',
+                    'float', 'uint64_t', 'size_t', 'VkDeviceSize', 'int64_t']
+
+NAMES_TO_IGNORE = ['sType', 'pNext', 'displayMode', 'display', 'currentDisplay']
+
+EXTENSION_TYPE_INSTANCE = 'instance'
+EXTENSION_TYPE_DEVICE = 'device'
+EXTENSION_TYPE_BOTH = 'both'
+
+# Types that need pNext Chains built. 'extends' is the xml tag used in the structextends member. 'type' can be device, instance, or both
+EXTENSION_CATEGORIES = OrderedDict((
+    ('phys_device_props2',
+        {'extends': 'VkPhysicalDeviceProperties2',
+         'type': EXTENSION_TYPE_BOTH,
+         'print_iterator': True,
+         'can_show_promoted_structs': True,
+         'ignore_vendor_exclusion': False}),
+    ('phys_device_mem_props2',
+        {'extends': 'VkPhysicalDeviceMemoryProperties2',
+         'type': EXTENSION_TYPE_DEVICE,
+         'print_iterator': False,
+         'can_show_promoted_structs': False,
+         'ignore_vendor_exclusion': False}),
+    ('phys_device_features2',
+        {'extends': 'VkPhysicalDeviceFeatures2',
+         'type': EXTENSION_TYPE_DEVICE,
+         'print_iterator': True,
+         'can_show_promoted_structs': True,
+         'ignore_vendor_exclusion': False}),
+    ('surface_capabilities2',
+        {'extends': 'VkSurfaceCapabilities2KHR',
+         'type': EXTENSION_TYPE_BOTH,
+         'print_iterator': True,
+         'can_show_promoted_structs': False,
+         'ignore_vendor_exclusion': False,
+         'exclude': ['VkSurfacePresentScalingCapabilitiesKHR', 'VkSurfacePresentModeCompatibilityKHR']}),
+    ('format_properties2',
+        {'extends': 'VkFormatProperties2',
+         'type': EXTENSION_TYPE_DEVICE,
+         'print_iterator': True,
+         'can_show_promoted_structs': False,
+         'ignore_vendor_exclusion': False}),
+    ('queue_properties2',
+        {'extends': 'VkQueueFamilyProperties2',
+         'type': EXTENSION_TYPE_DEVICE,
+         'print_iterator': True,
+         'can_show_promoted_structs': False,
+         'ignore_vendor_exclusion': False}),
+    ('video_profile_info',
+        {'extends': 'VkVideoProfileInfoKHR',
+         'type': EXTENSION_TYPE_DEVICE,
+         'print_iterator': True,
+         'can_show_promoted_structs': False,
+         'ignore_vendor_exclusion': True}),
+    ('video_capabilities',
+        {'extends': 'VkVideoCapabilitiesKHR',
+         'type': EXTENSION_TYPE_DEVICE,
+         'print_iterator': True,
+         'can_show_promoted_structs': False,
+         'ignore_vendor_exclusion': True,}),
+    ('video_format_properties',
+        {'extends': 'VkVideoFormatPropertiesKHR',
+         'type': EXTENSION_TYPE_DEVICE,
+         'print_iterator': True,
+         'can_show_promoted_structs': False,
+         'ignore_vendor_exclusion': True})
+                                   ))
+class VulkanInfoGenerator(BaseGenerator):
+    def __init__(self):
+        BaseGenerator.__init__(self)
+        self.format_ranges = []
+
+    def generate(self):
+        self.findFormatRanges()
+
+        # gather the types that are needed to generate
+        types_to_gen = set()
+        types_to_gen.update(ENUMS_TO_GEN)
+        types_to_gen.update(FLAGS_TO_GEN)
+        types_to_gen.update(STRUCTURES_TO_GEN)
+
+        extension_types = {}
+        for key, ext_info in EXTENSION_CATEGORIES.items():
+            extension_types[key] = []
+
+            for extended_struct in self.vk.structs[ext_info.get('extends')].extendedBy:
+                if ext_info.get('exclude') is not None and extended_struct in ext_info.get('exclude'):
+                    continue
+                elif ext_info.get('ignore_vendor_exclusion'):
+                    extension_types[key].append(extended_struct)
+                    continue
+                vendor_tags = []
+                for extension in self.vk.structs[extended_struct].extensions:
+                    vendor_tags.append(extension.split('_')[1])
+                if len(vendor_tags) == 0 or 'KHR' in vendor_tags or 'EXT' in vendor_tags:
+                    extension_types[key].append(extended_struct)
+            extension_types[key] = sorted(extension_types[key])
+            types_to_gen.update(extension_types[key])
+
+        # find all the types that need
+        types_to_gen.update(self.findAllTypesToGen(types_to_gen))
+
+        types_to_gen = sorted(types_to_gen)
+
+        comparison_types_to_gen = set()
+        comparison_types_to_gen.update(STRUCT_COMPARISONS_TO_GEN)
+        comparison_types_to_gen.update(self.findAllTypesToGen(comparison_types_to_gen))
+        comparison_types_to_gen = sorted(comparison_types_to_gen)
+
+
+        # print the types gathered
+        out = []
+        out.append(LICENSE_HEADER + '\n')
+        out.append('#include "vulkaninfo.h"\n')
+        out.append('#include "outputprinter.h"\n')
+        out.append(CUSTOM_FORMATTERS)
+
+        out.extend(self.genVideoEnums())
+
+        for enum in (e for e in types_to_gen if e in self.vk.enums):
+            out.extend(self.PrintEnumToString(self.vk.enums[enum]))
+            out.extend(self.PrintEnum(self.vk.enums[enum]))
+
+        # Need to go through all flags to find if they or their associated bitmask needs printing
+        # This is because both bitmask and flag types are generated in PrintBitMask
+        for name in (x for x in sorted(self.vk.flags.keys()) if x in types_to_gen or self.vk.flags[x].bitmaskName in types_to_gen):
+            bitmask = self.vk.bitmasks[self.vk.flags[name].bitmaskName]
+
+            out.extend(self.PrintBitMask(bitmask, bitmask.flagName))
+
+            if bitmask.flagName in FLAG_STRINGS_TO_GEN:
+                out.extend(self.PrintBitMaskToString(bitmask, bitmask.flagName))
+        # make sure dump functions for nested structures are declared before use
+        for s in (x for x in types_to_gen if x in self.vk.structs and x not in STRUCT_BLACKLIST):
+            out.extend(self.PrintStructure(self.vk.structs[s], True))
+        for s in (x for x in types_to_gen if x in self.vk.structs and x not in STRUCT_BLACKLIST):
+            out.extend(self.PrintStructure(self.vk.structs[s], False))
+
+        for key, value in EXTENSION_CATEGORIES.items():
+            out.extend(self.PrintChainStruct(key, extension_types[key], value))
+
+        for s in (x for x in comparison_types_to_gen if x in self.vk.structs):
+            out.extend(self.PrintStructComparisonForwardDecl(self.vk.structs[s]))
+        for s in (x for x in comparison_types_to_gen if x in self.vk.structs):
+            out.extend(self.PrintStructComparison(self.vk.structs[s]))
+        for s in (x for x in types_to_gen if x in self.vk.structs and x in STRUCT_SHORT_VERSIONS_TO_GEN):
+            out.extend(self.PrintStructShort(self.vk.structs[s]))
+
+        out.append('auto format_ranges = std::array{\n')
+        for f in self.format_ranges:
+            out.append(f'    FormatRange{{{f.minimum_instance_version}, {self.vk.extensions[f.extensions[0]].nameString if len(f.extensions) > 0 else "nullptr"}, ')
+            out.append(f'static_cast<VkFormat>({f.first_format}), static_cast<VkFormat>({f.last_format})}},\n')
+        out.append('};\n')
+
+        out.extend(self.genVideoProfileUtils())
+
+        self.write(''.join(out))
+
+
+    def genVideoEnums(self):
+        out = []
+        for enum in self.vk.videoStd.enums.values():
+            out.append(f'std::string {enum.name}String({enum.name} value) {{\n')
+            out.append('    switch (value) {\n')
+            for field in enum.fields:
+                # Ignore aliases
+                if field.value is not None:
+                    out.append(f'        case {field.name}: return "{field.name}";\n')
+            out.append(f'        default: return std::string("UNKNOWN_{enum.name}_value") + std::to_string(value);\n')
+            out.append('    }\n}\n')
+            out.append(f'void Dump{enum.name}(Printer &p, std::string name, {enum.name} value) {{\n')
+            out.append(f'    p.PrintKeyString(name, {enum.name}String(value));\n}}\n')
+        return out
+
+
+    # Utility to get the extension / version precondition of a list of type names
+    def GetTypesPrecondition(self, typelist, indent):
+        indent = ' ' * indent
+        out = []
+        extEnables = []
+        for typename in typelist:
+            extEnables.extend(self.vk.structs[typename].extensions)
+
+        version = None
+        for typename in typelist:
+            for v in self.vk.versions.values():
+                if typename in v.name:
+                    if version is not None and (v.major > version.major or (v.major == version.major and v.minor > version.minor)):
+                        version = v
+
+
+        has_version = version is not None
+        has_extNameStr = len(extEnables) > 0
+        if has_version or has_extNameStr:
+            out.append(f'{indent}if (')
+            has_printed_condition = False
+            if has_extNameStr:
+                for ext in extEnables:
+                    if has_printed_condition:
+                        out.append(f'\n{indent} || ')
+                    else:
+                        has_printed_condition = True
+                        if has_version:
+                            out.append('(')
+                    if self.vk.extensions[ext].device:
+                        out.append(f'gpu.CheckPhysicalDeviceExtensionIncluded({self.vk.extensions[ext].nameString})')
+                    else:
+                        assert False, 'Should never get here'
+            if has_version:
+                if has_printed_condition:
+                    out.append(f'\n{indent} || (gpu.api_version >= {version.nameApi})')
+                else:
+                    out.append(f'gpu.api_version >= {version.nameApi}')
+            out.append(') {\n')
+        else:
+            out = f'{indent}{{\n'
+        return out
+
+    # Utility to construct a capability prerequisite condition evaluation expression
+    def GetRequiredCapsCondition(self, structName, memberName, memberRef, value):
+        condition = ''
+        requiredCapStructDef = self.vk.structs[structName]
+        for member in requiredCapStructDef.members:
+            if member.name == memberName:
+                if member.type in self.vk.flags:
+                    # Check that the flags contain all the required values
+                    def genExpressionFromValue(value):
+                        return value if value == "" else f"({memberRef} & {value}) != 0"
+
+                    for char in condition:
+                        if char in ['(', ')', '+', ',']:
+                            condition += genExpressionFromValue(value)
+                            value = ""
+                            if char == '+':
+                                # '+' means AND
+                                condition += ' && '
+                            elif char == ',':
+                                # ',' means OR
+                                condition += ' || '
+                            else:
+                                condition += char
+                        else:
+                            value += char
+                    condition += genExpressionFromValue(value)
+                else:
+                    condition = f'{memberRef} == {value}'
+        if condition == '':
+            return 'true'
+        else:
+            return f'({condition})'
+
+    def genVideoProfileUtils(self):
+        out = []
+
+        # Generate video format properties comparator
+        out.append('''
+bool is_video_format_same(const VkVideoFormatPropertiesKHR &format_a, const VkVideoFormatPropertiesKHR &format_b) {
+    auto a = reinterpret_cast<const VkBaseInStructure*>(&format_a);
+    auto b = reinterpret_cast<const VkBaseInStructure*>(&format_b);
+    bool same = true;
+    while (same && a != nullptr && b != nullptr) {
+        if (a->sType != b->sType) {
+            // Structure type mismatch (extension structures are expected to be chained in the same order)
+            same = false;
+        } else {
+            switch (a->sType) {''')
+
+        if 'VkVideoFormatPropertiesKHR' in self.registry.validextensionstructs:
+            for extstruct in ['VkVideoFormatPropertiesKHR'] + self.registry.validextensionstructs['VkVideoFormatPropertiesKHR']:
+                extstructDef = self.vk.structs[extstruct]
+                out.append(f'''
+                case {extstructDef.sType}:
+                    same = same && memcmp(reinterpret_cast<const char*>(a) + sizeof(VkBaseInStructure),
+                                          reinterpret_cast<const char*>(b) + sizeof(VkBaseInStructure),
+                                          sizeof({extstruct}) - sizeof(VkBaseInStructure)) == 0;
+                    break;''')
+
+        out.append('''
+                default:
+                    // Unexpected structure type
+                    same = false;
+                    break;
+            }
+        }
+        a = a->pNext;
+        b = b->pNext;
+    }
+    return same;
+}
+''')
+
+        # Generate video profile info capture utilities
+        out.append('''
+std::vector<std::unique_ptr<AppVideoProfile>> enumerate_supported_video_profiles(AppGpu &gpu) {
+    std::vector<std::unique_ptr<AppVideoProfile>> result{};
+
+    struct ChromaSubsamplingInfo {
+        VkVideoChromaSubsamplingFlagsKHR value;
+        const char* name;
+    };
+    const std::vector<ChromaSubsamplingInfo> chroma_subsampling_list = {
+        {VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR, "4:2:0"},
+        {VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR, "4:2:2"},
+        {VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR, "4:4:4"},
+        {VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR, "monochrome"}
+    };
+
+    struct BitDepthInfo {
+        VkVideoComponentBitDepthFlagsKHR value;
+        const char* name;
+    };
+    const std::vector<BitDepthInfo> bit_depth_list = {
+        {VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, "8"},
+        {VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR, "10"},
+        {VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR, "12"}
+    };
+
+    auto find_caps_struct = [](const VkVideoCapabilitiesKHR &capabilities, VkStructureType stype) -> const VkBaseInStructure* {
+        auto p = reinterpret_cast<const VkBaseInStructure*>(&capabilities);
+        while (p != nullptr) {
+            if (p->sType == stype) {
+                return p;
+            }
+            p = p->pNext;
+        }
+        return nullptr;
+    };
+
+    auto base_format = []
+        (const ChromaSubsamplingInfo &chroma_subsampling, const BitDepthInfo &luma_bit_depth, const BitDepthInfo &chroma_bit_depth) {
+            std::string result{};
+            result += " (";
+            result += chroma_subsampling.name;
+            result += " ";
+            result += luma_bit_depth.name;
+            if (luma_bit_depth.value != chroma_bit_depth.value) {
+                result += ":";
+                result += chroma_bit_depth.name;
+            }
+            result += "-bit)";
+            return result;
+        };
+
+    auto add_profile = [&](
+        const std::string &name,
+        const VkVideoProfileInfoKHR &profile_info,
+        AppVideoProfile::CreateProfileInfoChainCb create_profile_info_chain,
+        AppVideoProfile::CreateCapabilitiesChainCb create_capabilities_chain,
+        const AppVideoProfile::CreateFormatPropertiesChainCbList &create_format_properties_chain_list,
+        AppVideoProfile::InitProfileCb init_profile) {
+            auto profile = std::make_unique<AppVideoProfile>(gpu, gpu.phys_device,
+                                                             name, profile_info,
+                                                             create_profile_info_chain,
+                                                             create_capabilities_chain,
+                                                             create_format_properties_chain_list,
+                                                             init_profile);
+            if (profile->supported) {
+                result.push_back(std::move(profile));
+            }
+        };
+''')
+
+        # Generate individual video profiles from the video codec metadata
+        for videoCodec in self.vk.videoCodecs.values():
+            # Ignore video codec categories
+            if videoCodec.value is None:
+                continue
+
+            out.append('\n')
+            out.extend(self.GetTypesPrecondition(videoCodec.profiles.keys(), 4))
+            out.append(f'{" " * 8}const std::string codec_name = "{videoCodec.name}";\n')
+
+            out.append('''
+        for (auto chroma_subsampling : chroma_subsampling_list) {
+            for (auto luma_bit_depth : bit_depth_list) {
+                for (auto chroma_bit_depth : bit_depth_list) {
+                    if (chroma_subsampling.value == VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR && luma_bit_depth.value != chroma_bit_depth.value) {
+                        // Ignore the chroma bit depth dimension for monochrome
+                        continue;
+                    }
+
+                    std::string profile_base_name = codec_name + base_format(chroma_subsampling, luma_bit_depth, chroma_bit_depth);
+''')
+
+            # Setup video profile info
+            out.append(f'{" " * 20}VkVideoProfileInfoKHR profile_info{{\n')
+            out.append(f'{" " * 20}    VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR,\n')
+            out.append(f'{" " * 20}    nullptr,\n')
+            out.append(f'{" " * 20}    {videoCodec.value},\n')
+            out.append(f'{" " * 20}    chroma_subsampling.value,\n')
+            out.append(f'{" " * 20}    luma_bit_depth.value,\n')
+            out.append(f'{" " * 20}    chroma_bit_depth.value\n')
+            out.append(f'{" " * 20}}};\n\n')
+
+            # Setup video profile info chain creation callback
+            out.append(f'{" " * 20}auto create_profile_info_chain = [&](const void **ppnext) -> std::unique_ptr<video_profile_info_chain> {{\n')
+            out.append(f'{" " * 20}    auto profile_info_chain = std::make_unique<video_profile_info_chain>();\n')
+            for profileStruct in videoCodec.profiles:
+                structDef = self.vk.structs[profileStruct]
+                out.append(self.AddGuardHeader(structDef))
+                out.append(f'{" " * 24}if (profile_info_chain != nullptr) {{\n')
+                out.append(f'{" " * 28}profile_info_chain->{profileStruct[2:]}.sType = {structDef.sType};\n')
+                out.append(f'{" " * 28}profile_info_chain->{profileStruct[2:]}.pNext = nullptr;\n')
+                out.append(f'{" " * 28}*ppnext = &profile_info_chain->{profileStruct[2:]};\n')
+                out.append(f'{" " * 28}ppnext = &profile_info_chain->{profileStruct[2:]}.pNext;\n')
+                out.append(f'{" " * 24}}}\n')
+                if structDef.protect:
+                    out.append(f'#else\n{" " * 20}profile_info_chain = nullptr;\n')
+                out.append(self.AddGuardFooter(structDef))
+            out.append(f'{" " * 20}    return profile_info_chain;\n')
+            out.append(f'{" " * 20}}};\n\n')
+
+            # Setup video capabilities chain creation callback
+            out.append(f'{" " * 20}auto create_capabilities_chain = [&](void **ppnext) -> std::unique_ptr<video_capabilities_chain> {{\n')
+            out.append(f'{" " * 20}    auto capabilities_chain = std::make_unique<video_capabilities_chain>();\n')
+            for capabilities in videoCodec.capabilities:
+                structDef = self.vk.structs[capabilities]
+                out.append(self.AddGuardHeader(structDef))
+                out.append(f'{" " * 24}if (capabilities_chain != nullptr) {{\n')
+                out.extend(self.GetTypesPrecondition([capabilities], 28))
+                out.append(f'{" " * 32}capabilities_chain->{capabilities[2:]}.sType = {structDef.sType};\n')
+                out.append(f'{" " * 32}capabilities_chain->{capabilities[2:]}.pNext = nullptr;\n')
+                out.append(f'{" " * 32}*ppnext = &capabilities_chain->{capabilities[2:]};\n')
+                out.append(f'{" " * 32}ppnext = &capabilities_chain->{capabilities[2:]}.pNext;\n')
+                out.append(f'{" " * 28}}}\n')
+                out.append(f'{" " * 24}}}\n')
+                out.append(self.AddGuardFooter(structDef))
+            out.append(f'{" " * 20}    return capabilities_chain;\n')
+            out.append(f'{" " * 20}}};\n\n')
+
+            # Setup video format properties chain creation callbacks
+            out.append(f'{" " * 20}const AppVideoProfile::CreateFormatPropertiesChainCbList create_format_properties_chain_list = {{\n')
+            for format in videoCodec.formats.values():
+                out.append(f'{" " * 24}AppVideoProfile::CreateFormatPropertiesChainCb {{\n')
+                out.append(f'{" " * 28}"{format.name}",\n')
+                out.append(f'{" " * 28}{format.usage.replace("+", " | ")},\n')
+
+                # Callback to check required capabilities
+                out.append(f'{" " * 28}[&](const VkVideoCapabilitiesKHR &capabilities) -> bool {{\n')
+                out.append(f'{" " * 28}    bool supported = true;\n')
+                for requiredCap in format.requiredCaps:
+                    structDef = self.vk.structs[requiredCap.struct]
+                    out.append(self.AddGuardHeader(structDef))
+                    out.extend(self.GetTypesPrecondition([requiredCap.struct], 32))
+                    out.append(f'{" " * 32}    auto caps = reinterpret_cast<const {requiredCap.struct}*>(find_caps_struct(capabilities, {structDef.sType}));\n')
+                    out.append(f'{" " * 32}    if (caps != nullptr) {{\n')
+                    out.append(f'{" " * 32}        supported = supported && {self.GetRequiredCapsCondition(requiredCap.struct, requiredCap.member, f"caps->{requiredCap.member}", requiredCap.value)};\n')
+                    out.append(f'{" " * 32}    }} else {{\n')
+                    out.append(f'{" " * 32}        supported = false;\n')
+                    out.append(f'{" " * 32}    }}\n')
+                    out.append(f'{" " * 32}}} else {{\n')
+                    out.append(f'{" " * 32}    supported = false;\n')
+                    out.append(f'{" " * 32}}}\n')
+                    if structDef.protect:
+                        out.append(f'#else\n{" " * 32}supported = false;\n')
+                    out.append(self.AddGuardFooter(structDef))
+                out.append(f'{" " * 28}    return supported;\n')
+                out.append(f'{" " * 28}}},\n')
+
+                # Callback to create video format properties chain
+                out.append(f'{" " * 28}[&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {{\n')
+                out.append(f'{" " * 28}    auto format_properties_chain = std::make_unique<video_format_properties_chain>();\n')
+                for formatProps in format.properties:
+                    structDef = self.vk.structs[formatProps]
+                    out.append(self.AddGuardHeader(structDef))
+                    out.append(f'{" " * 32}if (format_properties_chain != nullptr) {{\n')
+                    out.extend(self.GetTypesPrecondition([formatProps], 36))
+                    out.append(f'{" " * 40}format_properties_chain->{formatProps[2:]}.sType = {structDef.sType};\n')
+                    out.append(f'{" " * 40}format_properties_chain->{formatProps[2:]}.pNext = nullptr;\n')
+                    out.append(f'{" " * 40}*ppnext = &format_properties_chain->{formatProps[2:]};\n')
+                    out.append(f'{" " * 40}ppnext = &format_properties_chain->{formatProps[2:]}.pNext;\n')
+                    out.append(f'{" " * 36}}}\n')
+                    out.append(f'{" " * 32}}}\n')
+                    out.append(self.AddGuardFooter(structDef))
+                out.append(f'{" " * 28}    return format_properties_chain;\n')
+                out.append(f'{" " * 28}}},\n')
+
+                out.append(f'{" " * 24}}},\n')
+            out.append(f'{" " * 20}}};\n\n')
+
+            # Permute profiles for each profile struct member value
+            profiles = {'': []}
+            for profileStruct in videoCodec.profiles.values():
+                for profileStructMember in profileStruct.members.values():
+                    newProfiles = {}
+                    for profileStructMemberValue, profileStructMemberName in profileStructMember.values.items():
+                        for profileName, profile in profiles.items():
+                            # Only add video profile name suffix to the full descriptive name if not empty to avoid excess whitespace
+                            newProfileName = profileName if profileStructMemberName == '' else f'{profileName} {profileStructMemberName}'
+                            newProfiles[newProfileName] = profile + [{
+                                "struct": profileStruct.name,
+                                "member": profileStructMember.name,
+                                "value": profileStructMemberValue
+                            }]
+                    profiles = newProfiles
+
+            for profileName, profile in profiles.items():
+                out.append(f'{" " * 20}add_profile(profile_base_name + "{profileName}", profile_info,\n')
+                out.append(f'{" " * 20}            create_profile_info_chain, create_capabilities_chain,\n')
+                out.append(f'{" " * 20}            create_format_properties_chain_list,\n')
+                out.append(f'{" " * 20}            [](AppVideoProfile& profile) {{\n')
+                for profileStruct in videoCodec.profiles:
+                    structDef = self.vk.structs[profileStruct]
+                    out.append(self.AddGuardHeader(structDef))
+                    for elem in profile:
+                        if elem['struct'] == profileStruct:
+                            out.append(f'{" " * 24}profile.profile_info_chain->{elem["struct"][2:]}.{elem["member"]} = {elem["value"]};\n')
+                    out.append(self.AddGuardFooter(structDef))
+                out.append(f'{" " * 20}}});\n')
+
+            out.append(f'{" " * 16}}}\n')
+            out.append(f'{" " * 12}}}\n')
+            out.append(f'{" " * 8}}}\n')
+            out.append(f'{" " * 4}}}\n')
+
+        out.append('    return result;\n')
+        out.append('}\n\n')
+
+        return out
+
+
+    # finds all the ranges of formats from core (1.0), core versions (1.1+), and extensions
+    def findFormatRanges(self):
+        min_val = 2**32
+        prev_field = None
+        max_val = 0
+        for f in self.vk.enums['VkFormat'].fields:
+            if f.value is None:
+                continue
+            if prev_field is not None and f.value != prev_field.value + 1:
+                for ext in prev_field.extensions:
+                    if self.vk.extensions[ext].promotedTo is not None:
+                        self.format_ranges.append(VulkanFormatRange(self.vk.extensions[ext].promotedTo.replace("VK_", "VK_API_"), [], min_val, max_val))
+                        break
+                # only bother with the first extension
+                self.format_ranges.append(VulkanFormatRange(0, prev_field.extensions, min_val, max_val))
+                min_val = 2**32
+                max_val = 0
+            min_val = min(min_val, f.value)
+            max_val = max(max_val, f.value)
+
+            prev_field = f
+
+        for ext in prev_field.extensions:
+            if self.vk.extensions[ext].promotedTo is not None:
+                self.format_ranges.append(VulkanFormatRange(self.vk.extensions[ext].promotedTo.replace("VK_", "VK_API_"), [], min_val, max_val))
+                break
+
+        self.format_ranges.append(VulkanFormatRange(0, prev_field.extensions, min_val, max_val))
+
+    def findAllTypesToGen(self, initial_type_set):
+        out_set = set()
+        current_set = initial_type_set
+        while len(current_set) > 0:
+            out_set.update(current_set)
+            next_set = set()
+
+            for current_item in current_set:
+                if current_item in self.vk.structs:
+                    for member in self.vk.structs[current_item].members:
+                        if member.type not in out_set and member.name not in NAMES_TO_IGNORE:
+                            next_set.add(member.type)
+
+            current_set = next_set
+        return out_set
+
+    def AddGuardHeader(self,obj):
+        if obj is not None and obj.protect is not None:
+            return f'#ifdef {obj.protect}\n'
+        else:
+            return ''
+
+
+    def AddGuardFooter(self,obj):
+        if obj is not None and obj.protect is not None:
+            return f'#endif  // {obj.protect}\n'
+        else:
+            return ''
+
+    def PrintEnumToString(self,enum):
+        out = []
+        out.append(self.AddGuardHeader(enum))
+        out.append(f'std::string {enum.name}String({enum.name} value) {{\n')
+        out.append('    switch (value) {\n')
+        for v in enum.fields:
+            out.append(f'        case ({v.name}): return "{v.name[3:]}";\n')
+        out.append(f'        default: return std::string("UNKNOWN_{enum.name}_value") + std::to_string(value);\n')
+        out.append('    }\n}\n')
+        out.append(self.AddGuardFooter(enum))
+        return out
+
+
+    def PrintEnum(self,enum):
+        out = []
+        out.append(self.AddGuardHeader(enum))
+        out.append(f'''void Dump{enum.name}(Printer &p, std::string name, {enum.name} value) {{
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + {enum.name}String(value));
+    else
+        p.PrintKeyString(name, {enum.name}String(value));
+}}
+''')
+        out.append(self.AddGuardFooter(enum))
+        return out
+
+
+    def PrintGetFlagStrings(self,name, bitmask):
+        out = []
+        out.append(f'std::vector<const char *> {name}GetStrings({name} value) {{\n')
+        out.append('    std::vector<const char *> strings;\n')
+        # If a bitmask contains a field whose value is zero, we want to support printing the correct bitflag
+        # Otherwise, use "None" for when there are not bits set in the bitmask
+        if bitmask.flags[0].value != 0:
+            out.append('    if (value == 0) { strings.push_back("None"); return strings; }\n')
+        else:
+            out.append(f'    if (value == 0) {{ strings.push_back("{bitmask.flags[0].name[3:]}"); return strings; }}\n')
+        for v in bitmask.flags:
+            # only check single-bit flags
+            if v.value != 0 and (v.value & (v.value - 1)) == 0:
+                out.append(f'    if ({v.name} & value) strings.push_back("{v.name[3:]}");\n')
+        out.append('    return strings;\n}\n')
+        return out
+
+
+    def PrintFlags(self, bitmask, name):
+        out = []
+        out.append(f'void Dump{name}(Printer &p, std::string name, {name} value) {{\n')
+        out.append(f'''    if (static_cast<{bitmask.name}>(value) == 0) {{
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output)
+            p.SetAsType().PrintString("None");
+        return;
+    }}
+    auto strings = {bitmask.name}GetStrings(static_cast<{bitmask.name}>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for(auto& str : strings){{
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }}
+}}
+''')
+        return out
+
+
+    def PrintFlagBits(self, bitmask):
+        return [f'''void Dump{bitmask.name}(Printer &p, std::string name, {bitmask.name} value) {{
+    auto strings = {bitmask.name}GetStrings(value);
+    if (strings.size() > 0) {{
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }}
+}}
+''']
+
+
+    def PrintBitMask(self,bitmask, name):
+        out = []
+        out.extend(self.PrintGetFlagStrings(bitmask.name, bitmask))
+        out.append(self.AddGuardHeader(bitmask))
+        out.extend(self.PrintFlags(bitmask, name))
+        out.extend(self.PrintFlagBits(bitmask))
+        out.append(self.AddGuardFooter(bitmask))
+        out.append('\n')
+        return out
+
+
+    def PrintBitMaskToString(self, bitmask, name):
+        out = []
+        out.append(self.AddGuardHeader(bitmask))
+        out.append(f'std::string {name}String({name} value) {{\n')
+        out.append('    std::string out;\n')
+        out.append('    bool is_first = true;\n')
+        for v in bitmask.flags:
+            out.append(f'    if ({v.name} & value) {{\n')
+            out.append('        if (is_first) { is_first = false; } else { out += " | "; }\n')
+            out.append(f'        out += "{str(v.name)[3:]}";\n')
+            out.append('    }\n')
+        out.append('    return out;\n')
+        out.append('}\n')
+        out.append(self.AddGuardFooter(bitmask))
+        return out
+
+
+    def PrintStructure(self,struct, declare_only):
+        if len(struct.members) == 0:
+            return []
+        out = []
+        out.append(self.AddGuardHeader(struct))
+        max_key_len = 0
+        for v in struct.members:
+            if (v.type in PREDEFINED_TYPES or v.type in STRUCT_BLACKLIST) and (v.length is None or v.type in ['char'] or v.fixedSizeArray[0] in ['VK_UUID_SIZE', 'VK_LUID_SIZE']):
+                max_key_len = max(max_key_len, len(v.name))
+        out.append(f'void Dump{struct.name}(Printer &p, std::string name, const {struct.name} &obj)')
+        if declare_only:
+            out.append(';\n')
+            out.append(self.AddGuardFooter(struct))
+            return out
+        out.append(' {\n')
+        if struct.name == 'VkPhysicalDeviceLimits':
+            out.append('    if (p.Type() == OutputType::json)\n')
+            out.append('        p.ObjectStart("limits");\n')
+            out.append('    else\n')
+            out.append('        p.SetSubHeader().ObjectStart(name);\n')
+        elif struct.name == 'VkPhysicalDeviceSparseProperties':
+            out.append('    if (p.Type() == OutputType::json)\n')
+            out.append('        p.ObjectStart("sparseProperties");\n')
+            out.append('    else\n')
+            out.append('        p.SetSubHeader().ObjectStart(name);\n')
+        else:
+            out.append('    ObjectWrapper object{p, name};\n')
+        if max_key_len > 0:
+            out.append(f'    p.SetMinKeyWidth({max_key_len});\n')
+        for v in struct.members:
+            # strings
+            if v.type == 'char':
+                if v.pointer == True:
+                    out.append(f'    if (obj.{v.name} == nullptr) {{')
+                    out.append(f'        p.PrintKeyString("{v.name}", "NULL");\n')
+                    out.append('    } else {')
+                out.append(f'    p.PrintKeyString("{v.name}", obj.{v.name});\n')
+                if v.pointer == True:
+                        out.append('    }')
+            # arrays
+            elif v.length is not None:
+                # uuid's
+                if v.type == 'uint8_t' and (v.fixedSizeArray[0] == 'VK_LUID_SIZE' or v.fixedSizeArray[0] == 'VK_UUID_SIZE'):  # VK_UUID_SIZE
+                    if v.fixedSizeArray[0] == 'VK_LUID_SIZE':
+                        out.append('    if (obj.deviceLUIDValid) { // special case\n')
+                    out.append(f'    p.PrintKeyValue("{v.name}", obj.{v.name});\n')
+                    if v.fixedSizeArray[0] == 'VK_LUID_SIZE':
+                        out.append('    }\n')
+                elif struct.name == 'VkQueueFamilyGlobalPriorityProperties' and v.name == 'priorities':
+                    out.append(f'    ArrayWrapper arr(p,"{v.name}", obj.priorityCount);\n')
+                    out.append('    for (uint32_t i = 0; i < obj.priorityCount; i++) {\n')
+                    out.append('       if (p.Type() == OutputType::json)\n')
+                    out.append('           p.PrintString(std::string("VK_") + VkQueueGlobalPriorityString(obj.priorities[i]));\n')
+                    out.append('       else\n')
+                    out.append('           p.PrintString(VkQueueGlobalPriorityString(obj.priorities[i]));\n')
+                    out.append('    }\n')
+                elif len(v.fixedSizeArray) == 2:
+                    out.append(f'    {{\n        ArrayWrapper arr(p,"{v.name}", ' + v.fixedSizeArray[0] + ');\n')
+                    out.append(f'        for (uint32_t i = 0; i < {v.fixedSizeArray[0]}; i++) {{\n')
+                    out.append(f'           for (uint32_t j = 0; j < {v.fixedSizeArray[1]}; j++) {{\n')
+                    out.append(f'                p.PrintElement(obj.{v.name}[i][j]); }} }}\n')
+                    out.append('    }\n')
+                elif len(v.fixedSizeArray) == 1:
+                    out.append(f'    {{\n        ArrayWrapper arr(p,"{v.name}", ' + v.fixedSizeArray[0] + ');\n')
+                    out.append(f'        for (uint32_t i = 0; i < {v.fixedSizeArray[0]}; i++) {{ p.PrintElement(obj.{v.name}[i]); }}\n')
+                    out.append('    }\n')
+                else:  # dynamic array length based on other member
+                    out.append(f'    if (obj.{v.length} == 0 || obj.{v.name} == nullptr) {{\n')
+                    out.append(f'        p.PrintKeyString("{v.name}", "NULL");\n')
+                    out.append('    } else {\n')
+                    out.append(f'        ArrayWrapper arr(p,"{v.name}", obj.{v.length});\n')
+                    out.append(f'        for (uint32_t i = 0; i < obj.{v.length}; i++) {{\n')
+                    out.append(f'            Dump{v.type}(p, std::to_string(i), obj.{v.name}[i]);\n')
+                    out.append('        }\n')
+                    out.append('    }\n')
+            elif v.type == 'VkBool32':
+                out.append(f'    p.PrintKeyBool("{v.name}", static_cast<bool>(obj.{v.name}));\n')
+            elif v.type == 'uint8_t':
+                out.append(f'    p.PrintKeyValue("{v.name}", static_cast<uint32_t>(obj.{v.name}));\n')
+            elif v.type == 'VkDeviceSize' or (v.type == 'uint32_t' and v.name in ['vendorID', 'deviceID']):
+                out.append(f'    p.PrintKeyValue("{v.name}", to_hex_str(p, obj.{v.name}));\n')
+            elif v.type in PREDEFINED_TYPES:
+                out.append(f'    p.PrintKeyValue("{v.name}", obj.{v.name});\n')
+            elif v.name not in NAMES_TO_IGNORE:
+                # if it is an enum/flag/bitmask
+                if v.type in ['VkFormatFeatureFlags', 'VkFormatFeatureFlags2']:
+                    out.append('    p.SetOpenDetails();\n') # special case so that feature flags are open in html output
+                out.append(f'    Dump{v.type}(p, "{v.name}", obj.{v.name});\n')
+
+        if struct.name in ['VkPhysicalDeviceLimits', 'VkPhysicalDeviceSparseProperties']:
+            out.append('    p.ObjectEnd();\n')
+        out.append('}\n')
+
+        out.append(self.AddGuardFooter(struct))
+        return out
+
+
+    def PrintStructShort(self,struct):
+        out = []
+        out.append(self.AddGuardHeader(struct))
+        out.append(f'std::ostream &operator<<(std::ostream &o, {struct.name} &obj) {{\n')
+        out.append('    return o << "(" << ')
+
+        first = True
+        for v in struct.members:
+            if first:
+                first = False
+                out.append(f'obj.{v.name} << ')
+            else:
+                out.append(f'\',\' << obj.{v.name} << ')
+        out.append('")";\n')
+        out.append('}\n')
+        out.append(self.AddGuardFooter(struct))
+        return out
+
+    def PrintChainStruct(self, listName, structs_to_print, chain_details):
+        version_desc = ''
+        if chain_details.get('type') in [EXTENSION_TYPE_DEVICE, EXTENSION_TYPE_BOTH]:
+            version_desc = 'gpu.api_version'
+        else:
+            version_desc = 'inst.instance_version'
+
+        out = []
+
+        # use default constructor and delete copy & move operators
+        out.append(f'''struct {listName}_chain {{
+    {listName}_chain() = default;
+    {listName}_chain(const {listName}_chain &) = delete;
+    {listName}_chain& operator=(const {listName}_chain &) = delete;
+    {listName}_chain({listName}_chain &&) = delete;
+    {listName}_chain& operator=({listName}_chain &&) = delete;
+''')
+
+        out.append('    void* start_of_chain = nullptr;\n')
+        for s in structs_to_print:
+            if s in STRUCT_BLACKLIST:
+                continue
+            struct = self.vk.structs[s]
+            out.append(self.AddGuardHeader(struct))
+            if struct.sType is not None:
+                out.append(f'    {struct.name} {struct.name[2:]}{{}};\n')
+                # Specific versions of drivers have an incorrect definition of the size of these structs.
+                # We need to artificially pad the structure it just so the driver doesn't write out of bounds and
+                # into other structures that are adjacent. This bug comes from the in-development version of
+                # the extension having a larger size than the final version, so older drivers try to write to
+                # members which don't exist.
+                if struct.name in ['VkPhysicalDeviceShaderIntegerDotProductFeatures', 'VkPhysicalDeviceHostImageCopyFeaturesEXT']:
+                    out.append(f'    char {struct.name}_padding[64];\n')
+                for member in struct.members:
+                    if member.length is not None and len(member.fixedSizeArray) == 0:
+                        out.append(f'    std::vector<{member.type}> {struct.name}_{member.name};\n')
+            out.append(self.AddGuardFooter(struct))
+        out.append('    void initialize_chain(')
+        args = []
+        if chain_details.get('type') in [EXTENSION_TYPE_INSTANCE, EXTENSION_TYPE_BOTH]:
+            args.append('AppInstance &inst')
+        if chain_details.get('type') in [EXTENSION_TYPE_DEVICE, EXTENSION_TYPE_BOTH]:
+            args.append('AppGpu &gpu')
+        if chain_details.get('can_show_promoted_structs'):
+            args.append('bool show_promoted_structs')
+        out.append(f'{", ".join(args)}) noexcept {{\n')
+        for s in structs_to_print:
+            if s in STRUCT_BLACKLIST:
+                continue
+            struct = self.vk.structs[s]
+
+            out.append(self.AddGuardHeader(struct))
+            out.append(f'        {struct.name[2:]}.sType = {struct.sType};\n')
+            out.append(self.AddGuardFooter(struct))
+
+        out.append('        std::vector<VkBaseOutStructure*> chain_members{};\n')
+        for s in structs_to_print:
+            if s in STRUCT_BLACKLIST:
+                continue
+            struct = self.vk.structs[s]
+            out.append(self.AddGuardHeader(struct))
+
+            has_version = struct.version is not None
+            has_extNameStr = len(struct.extensions) > 0 or len(struct.aliases) > 0
+            if has_version or has_extNameStr:
+                out.append('        if (')
+                has_printed_condition = False
+                if has_extNameStr:
+                    for ext in struct.extensions:
+                        if has_printed_condition:
+                            out.append('\n         || ')
+                        else:
+                            has_printed_condition = True
+                            if has_version:
+                                out.append('(')
+                        if self.vk.extensions[ext].device:
+                            out.append(f'gpu.CheckPhysicalDeviceExtensionIncluded({self.vk.extensions[ext].nameString})')
+                        elif self.vk.extensions[ext].instance:
+                            out.append(f'inst.CheckExtensionEnabled({self.vk.extensions[ext].nameString})')
+                        else:
+                            assert False, 'Should never get here'
+                if has_version:
+                    str_show_promoted_structs = '|| show_promoted_structs' if chain_details.get('can_show_promoted_structs') else ''
+                    if struct.name in STRUCT_1_1_LIST:
+                        out.append(f'{version_desc} == {struct.version.nameApi} {str_show_promoted_structs}')
+                    elif has_printed_condition:
+                        out.append(f')\n            && ({version_desc} < {struct.version.nameApi} {str_show_promoted_structs})')
+                    else:
+                        out.append(f'({version_desc} >= {struct.version.nameApi})')
+                out.append(')\n            ')
+            else:
+                out.append('        ')
+            out.append(f'chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&{struct.name[2:]}));\n')
+            out.append(self.AddGuardFooter(struct))
+        chain_param_list = []
+        chain_arg_list = []
+        if chain_details.get('type') in [EXTENSION_TYPE_INSTANCE, EXTENSION_TYPE_BOTH]:
+            chain_param_list.append('AppInstance &inst')
+            chain_arg_list.append('inst')
+        if chain_details.get('type') in [EXTENSION_TYPE_DEVICE, EXTENSION_TYPE_BOTH]:
+            chain_param_list.append('AppGpu &gpu')
+            chain_arg_list.append('gpu')
+        if chain_details.get('can_show_promoted_structs'):
+            chain_param_list.append('bool show_promoted_structs')
+            chain_arg_list.append('show_promoted_structs')
+
+        out.append(f'''
+        if (!chain_members.empty()) {{
+            for(size_t i = 0; i < chain_members.size() - 1; i++){{
+                chain_members[i]->pNext = chain_members[i + 1];
+            }}
+            start_of_chain = chain_members[0];
+        }}
+    }}
+}};
+void setup_{listName}_chain({chain_details['extends']}& start, std::unique_ptr<{listName}_chain>& chain, {','.join(chain_param_list)}){{
+    chain = std::unique_ptr<{listName}_chain>(new {listName}_chain());
+    chain->initialize_chain({','.join(chain_arg_list)});
+    start.pNext = chain->start_of_chain;
+}};
+''')
+        if chain_details.get('print_iterator'):
+            out.append('\n')
+            out.append(f'void chain_iterator_{listName}(')
+            args = ['Printer &p']
+            if chain_details.get('type') in [EXTENSION_TYPE_INSTANCE, EXTENSION_TYPE_BOTH]:
+                args.append('AppInstance &inst')
+            if chain_details.get('type') in [EXTENSION_TYPE_DEVICE, EXTENSION_TYPE_BOTH]:
+                args.append('AppGpu &gpu')
+            if chain_details.get('can_show_promoted_structs'):
+                args.append('bool show_promoted_structs')
+            args.append('const void * place')
+            out.append(f'{", ".join(args)}) {{\n')
+            out.append('    while (place) {\n')
+            out.append('        const VkBaseOutStructure *structure = (const VkBaseOutStructure *)place;\n')
+            out.append('        p.SetSubHeader();\n')
+
+            for s in structs_to_print:
+                if s in STRUCT_BLACKLIST:
+                    continue
+                struct = self.vk.structs[s]
+
+                out.append(self.AddGuardHeader(struct))
+                out.append(f'        if (structure->sType == {struct.sType}')
+                if struct.name in PORTABILITY_STRUCTS:
+                    out.append(' && p.Type() != OutputType::json')
+                out.append(') {\n')
+                out.append(f'            const {struct.name}* props = (const {struct.name}*)structure;\n')
+                out.extend(self.PrintStructNameDecisionLogic(struct, version_desc, chain_details.get('can_show_promoted_structs')))
+                out.append('            p.AddNewline();\n')
+                out.append('        }\n')
+                out.append(self.AddGuardFooter(struct))
+            out.append('        place = structure->pNext;\n')
+            out.append('    }\n')
+            out.append('}\n')
+
+        out.append('\n')
+        out.append(f'bool prepare_{listName}_twocall_chain_vectors(std::unique_ptr<{listName}_chain>& chain) {{\n')
+        out.append('    (void)chain;\n')
+        is_twocall = False
+        for s in structs_to_print:
+            if s in STRUCT_BLACKLIST:
+                continue
+            struct = self.vk.structs[s]
+            has_length = False
+            for member in struct.members:
+                if member.length is not None and len(member.fixedSizeArray) == 0:
+                    has_length = True
+            if not has_length:
+                continue
+            out.append(self.AddGuardHeader(struct))
+            for member in struct.members:
+                if member.length is not None and len(member.fixedSizeArray) == 0:
+                    out.append(f'    chain->{struct.name}_{member.name}.resize(chain->{struct.name[2:]}.{member.length});\n')
+                    out.append(f'    chain->{struct.name[2:]}.{member.name} = chain->{struct.name}_{member.name}.data();\n')
+            out.append(self.AddGuardFooter(struct))
+            is_twocall = True
+        out.append(f'    return {"true" if is_twocall else "false"};\n')
+        out.append('}\n')
+
+        return out
+
+    def GetStructCheckStringForMatchingExtension(self, struct, structName):
+        for ext_name in struct.extensions:
+            ext = self.vk.extensions[ext_name]
+            vendor = ext.name.split('_')[1]
+            if structName.endswith(vendor):
+                if ext.device:
+                    return f'gpu.CheckPhysicalDeviceExtensionIncluded({ext.nameString})'
+                elif ext.instance:
+                    return f'inst.CheckExtensionEnabled({ext.nameString})'
+        return None
+
+    # Function is complex because it has to do the following:
+    # Always print the struct with the most appropriate name given the gpu api version & enabled instance/device extensions
+    # Print struct aliases when --show-promoted-structs is set
+    # Not let alias printing duplicate the most appropriate name
+    def PrintStructNameDecisionLogic(self, struct, version_desc, can_show_promoted_structs):
+        out = []
+        out.append(f'{" " * 12}const char* name = ')
+        # Get a list of all the conditions to check and the type name to use
+        check_list = []
+        if struct.version is not None:
+            check_list.append([f'{version_desc} >= {struct.version.nameApi}', struct.name])
+        else:
+            check_list.append([f'{self.GetStructCheckStringForMatchingExtension(struct, struct.name)}', struct.name])
+
+        for alias in struct.aliases:
+            ext_str = self.GetStructCheckStringForMatchingExtension(struct, alias)
+            if ext_str is not None:
+                check_list.append([f'{self.GetStructCheckStringForMatchingExtension(struct, alias)}', alias])
+        end_parens = ''
+        # Turn the conditions into a nested ternary condition -
+        for check in check_list:
+            if check == check_list[-1]:
+                out.append( f'"{check[1]}"')
+            else:
+                out.append( f'{check[0]} ? "{check[1]}" : (')
+                end_parens += ')'
+        out.append(f'{end_parens};\n')
+        out.append(f'{" " * 12}Dump{struct.name}(p, name, *props);\n')
+        if not can_show_promoted_structs:
+            return out
+        for alias in struct.aliases:
+            ext_str = self.GetStructCheckStringForMatchingExtension(struct, alias)
+            if ext_str is not None:
+                out.append(f'{" " * 12}if (show_promoted_structs && strcmp(name, "{alias}") != 0 && {ext_str}) {{\n')
+                out.append(f'{" " * 16}p.AddNewline();\n')
+                out.append(f'{" " * 16}p.SetSubHeader();\n')
+                out.append(f'{" " * 16}Dump{struct.name}(p, "{alias}", *props);\n')
+                out.append(f'{" " * 12}}}\n')
+        return out
+
+    def PrintStructComparisonForwardDecl(self,structure):
+        out = []
+        out.append(f'bool operator==(const {structure.name} & a, const {structure.name} b);\n')
+        return out
+
+
+    def PrintStructComparison(self,structure):
+        out = []
+        out.append(f'bool operator==(const {structure.name} & a, const {structure.name} b) {{\n')
+        out.append('    return ')
+        is_first = True
+        for m in structure.members:
+            if m.name not in NAMES_TO_IGNORE:
+                if not is_first:
+                    out.append('\n        && ')
+                else:
+                    is_first = False
+                out.append(f'a.{m.name} == b.{m.name}')
+        out.append(';\n')
+        out.append('}\n')
+        return out
+
+class VulkanFormatRange:
+    def __init__(self, min_inst_version, extensions, first, last):
+        self.minimum_instance_version = min_inst_version
+        self.extensions = extensions
+        self.first_format = first
+        self.last_format = last
diff --git a/tools/Vulkan-Tools/scripts/gn/DEPS b/tools/Vulkan-Tools/scripts/gn/DEPS
new file mode 100644
index 00000000..8cf931a8
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/gn/DEPS
@@ -0,0 +1,68 @@
+gclient_gn_args_file = 'build/config/gclient_args.gni'
+
+vars = {
+  'chromium_git': 'https://chromium.googlesource.com',
+  'ninja_version': 'version:2@1.11.1.chromium.6',
+}
+
+deps = {
+
+  'build': {
+    'url': '{chromium_git}/chromium/src/build.git@1015724d82945f9ef7e51c6f804034ccf5f79951',
+  },
+
+  'buildtools': {
+    'url': '{chromium_git}/chromium/src/buildtools.git@3c7e3f1b8b1e4c0b6ec693430379cea682de78d6',
+  },
+
+  'buildtools/linux64': {
+    'packages': [
+      {
+        'package': 'gn/gn/linux-${{arch}}',
+        'version': 'git_revision:5e19d2fb166fbd4f6f32147fbb2f497091a54ad8',
+      }
+    ],
+    'dep_type': 'cipd',
+    'condition': 'host_os == "linux"',
+  },
+
+  'testing': {
+    'url': '{chromium_git}/chromium/src/testing@949b2864b6bd27656753b917c9aa7731dc7a06f6',
+  },
+
+  'tools/clang': {
+    'url': '{chromium_git}/chromium/src/tools/clang.git@566877f1ff1a5fa6beaca3ab4b47bd0b92eb614f',
+  },
+
+  'third_party/ninja': {
+    'packages': [
+      {
+        'package': 'infra/3pp/tools/ninja/${{platform}}',
+        'version': Var('ninja_version'),
+      }
+    ],
+    'dep_type': 'cipd',
+  },
+
+}
+
+hooks = [
+  {
+    'name': 'sysroot_x64',
+    'pattern': '.',
+    'condition': 'checkout_linux and checkout_x64',
+    'action': ['python3', 'build/linux/sysroot_scripts/install-sysroot.py',
+               '--arch=x64'],
+  },
+  {
+    # Note: On Win, this should run after win_toolchain, as it may use it.
+    'name': 'clang',
+    'pattern': '.',
+    'action': ['python3', 'tools/clang/scripts/update.py'],
+  },
+]
+
+recursedeps = [
+  # buildtools provides clang_format.
+  'buildtools',
+]
diff --git a/tools/Vulkan-Tools/scripts/gn/generate_vulkan_icd_json.py b/tools/Vulkan-Tools/scripts/gn/generate_vulkan_icd_json.py
new file mode 100755
index 00000000..467ba616
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/gn/generate_vulkan_icd_json.py
@@ -0,0 +1,120 @@
+#!/usr/bin/env python
+
+# Copyright (c) 2022-2023 LunarG, Inc.
+# Copyright (C) 2016 The ANGLE Project Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Generate copies of the Vulkan layers JSON files, with no paths, forcing
+Vulkan to use the default search path to look for layers."""
+
+from __future__ import print_function
+
+import argparse
+import glob
+import json
+import os
+import platform
+import sys
+
+def glob_slash(dirname):
+    r"""Like regular glob but replaces \ with / in returned paths."""
+    return [s.replace('\\', '/') for s in glob.glob(dirname)]
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--icd', action='store_true')
+    parser.add_argument('--no-path-prefix', action='store_true')
+    parser.add_argument('--platform', type=str, default=platform.system(),
+        help='Target platform to build validation layers for: '
+             'Linux|Darwin|Windows|Fuchsia|...')
+    parser.add_argument('source_dir')
+    parser.add_argument('target_dir')
+    parser.add_argument('json_files', nargs='*')
+    args = parser.parse_args()
+
+    source_dir = args.source_dir
+    target_dir = args.target_dir
+
+    json_files = [j for j in args.json_files if j.endswith('.json')]
+    json_in_files = [j for j in args.json_files if j.endswith('.json.in')]
+
+    data_key = 'ICD' if args.icd else 'layer'
+
+    if not os.path.isdir(source_dir):
+        print(source_dir + ' is not a directory.', file=sys.stderr)
+        return 1
+
+    if not os.path.exists(target_dir):
+        os.makedirs(target_dir)
+
+    # Copy the *.json files from source dir to target dir
+    if (set(glob_slash(os.path.join(source_dir, '*.json'))) != set(json_files)):
+        print(glob.glob(os.path.join(source_dir, '*.json')))
+        print('.json list in gn file is out-of-date', file=sys.stderr)
+        return 1
+
+    for json_fname in json_files:
+        if not json_fname.endswith('.json'):
+            continue
+        with open(json_fname) as infile:
+            data = json.load(infile)
+
+        # Update the path.
+        if not data_key in data:
+            raise Exception(
+                "Could not find '%s' key in %s" % (data_key, json_fname))
+
+        # The standard validation layer has no library path.
+        if 'library_path' in data[data_key]:
+            prev_name = os.path.basename(data[data_key]['library_path'])
+            data[data_key]['library_path'] = prev_name
+
+        target_fname = os.path.join(target_dir, os.path.basename(json_fname))
+        with open(target_fname, 'w') as outfile:
+            json.dump(data, outfile)
+
+    # Set json file prefix and suffix for generating files, default to Linux.
+    if args.no_path_prefix:
+        relative_path_prefix = ''
+    elif args.platform == 'Windows':
+        relative_path_prefix = r'..\\'  # json-escaped, hence two backslashes.
+    else:
+        relative_path_prefix = '../lib'
+    file_type_suffix = '.so'
+    if args.platform == 'Windows':
+        file_type_suffix = '.dll'
+    elif args.platform == 'Darwin':
+        file_type_suffix = '.dylib'
+
+    # For each *.json.in template files in source dir generate actual json file
+    # in target dir
+    if (set(glob_slash(os.path.join(source_dir, '*.json.in'))) !=
+            set(json_in_files)):
+        print('.json.in list in gn file is out-of-date', file=sys.stderr)
+        return 1
+    for json_in_name in json_in_files:
+        if not json_in_name.endswith('.json.in'):
+            continue
+        json_in_fname = os.path.basename(json_in_name)
+        layer_name = json_in_fname[:-len('.json.in')]
+        layer_lib_name = layer_name + file_type_suffix
+        json_out_fname = os.path.join(target_dir, json_in_fname[:-len('.in')])
+        with open(json_out_fname,'w') as json_out_file, \
+             open(json_in_name) as infile:
+            for line in infile:
+                line = line.replace('@JSON_LIBRARY_PATH@', relative_path_prefix + layer_lib_name)
+                json_out_file.write(line)
+
+if __name__ == '__main__':
+    sys.exit(main())
diff --git a/tools/Vulkan-Tools/scripts/gn/gn.py b/tools/Vulkan-Tools/scripts/gn/gn.py
new file mode 100755
index 00000000..52b20c58
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/gn/gn.py
@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+# Copyright 2023 The Khronos Group Inc.
+# Copyright 2023 Valve Corporation
+# Copyright 2023 LunarG, Inc.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+import subprocess
+import sys
+
+# helper to define paths relative to the repo root
+def RepoRelative(path):
+    return os.path.abspath(os.path.join(os.path.dirname(__file__), '../../', path))
+
+def BuildGn():
+    if not os.path.exists(RepoRelative("depot_tools")):
+        print("Cloning Chromium depot_tools\n", flush=True)
+        clone_cmd = 'git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git depot_tools'.split(" ")
+        subprocess.call(clone_cmd)
+
+    os.environ['PATH'] = os.environ.get('PATH') + ":" + RepoRelative("depot_tools")
+
+    print("Updating Repo Dependencies and GN Toolchain\n", flush=True)
+    update_cmd = './scripts/gn/update_deps.sh'
+    subprocess.call(update_cmd)
+
+    print("Checking Header Dependencies\n", flush=True)
+    gn_check_cmd = 'gn gen --check out/Debug'.split(" ")
+    subprocess.call(gn_check_cmd)
+
+    print("Generating Ninja Files\n", flush=True)
+    gn_gen_cmd = 'gn gen out/Debug'.split(" ")
+    subprocess.call(gn_gen_cmd)
+
+    print("Running Ninja Build\n", flush=True)
+    ninja_build_cmd = 'ninja -C out/Debug'.split(" ")
+    subprocess.call(ninja_build_cmd)
+
+#
+# Module Entrypoint
+def main():
+    try:
+        BuildGn()
+
+    except subprocess.CalledProcessError as proc_error:
+        print('Command "%s" failed with return code %s' % (' '.join(proc_error.cmd), proc_error.returncode))
+        sys.exit(proc_error.returncode)
+    except Exception as unknown_error:
+        print('An unkown error occured: %s', unknown_error)
+        sys.exit(1)
+
+    sys.exit(0)
+
+if __name__ == '__main__':
+    main()
diff --git a/tools/Vulkan-Tools/scripts/gn/secondary/build_overrides/build.gni b/tools/Vulkan-Tools/scripts/gn/secondary/build_overrides/build.gni
new file mode 100644
index 00000000..dbf47039
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/gn/secondary/build_overrides/build.gni
@@ -0,0 +1,18 @@
+# Copyright (c) 2019-2023 LunarG, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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_with_chromium = false
+ignore_elf32_limitations = true
+linux_use_bundled_binutils_override = false
+use_system_xcode = true
diff --git a/tools/Vulkan-Tools/scripts/gn/secondary/build_overrides/vulkan_headers.gni b/tools/Vulkan-Tools/scripts/gn/secondary/build_overrides/vulkan_headers.gni
new file mode 100644
index 00000000..5f24b39e
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/gn/secondary/build_overrides/vulkan_headers.gni
@@ -0,0 +1,15 @@
+# Copyright (c) 2020-2023 LunarG, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+vulkan_use_x11 = true
diff --git a/tools/Vulkan-Tools/scripts/gn/secondary/build_overrides/vulkan_tools.gni b/tools/Vulkan-Tools/scripts/gn/secondary/build_overrides/vulkan_tools.gni
new file mode 100644
index 00000000..c62fb64d
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/gn/secondary/build_overrides/vulkan_tools.gni
@@ -0,0 +1,21 @@
+# Copyright (c) 2019-2023 LunarG, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Paths to vulkan tools dependencies
+vulkan_headers_dir = "//external/Vulkan-Headers"
+
+# Subdirectories for generated files
+vulkan_data_subdir = ""
+vulkan_gen_subdir = ""
+
diff --git a/tools/Vulkan-Tools/scripts/gn/update_deps.sh b/tools/Vulkan-Tools/scripts/gn/update_deps.sh
new file mode 100755
index 00000000..763c3058
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/gn/update_deps.sh
@@ -0,0 +1,49 @@
+#!/bin/sh
+
+# Copyright (c) 2019-2023 LunarG, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Execute at repo root
+cd "$(dirname $0)/../../"
+
+# Use update_deps.py to update source dependencies from /scripts/known_good.json
+scripts/update_deps.py --dir="external" --no-build
+
+cat << EOF > .gn
+buildconfig = "//build/config/BUILDCONFIG.gn"
+secondary_source = "//scripts/gn/secondary/"
+
+script_executable = "python3"
+
+default_args = {
+    clang_use_chrome_plugins = false
+    use_custom_libcxx = false
+}
+EOF
+
+# Use gclient to update toolchain dependencies from /scripts/gn/DEPS (from chromium)
+cat << EOF >> .gclient
+solutions = [
+  { "name"        : ".",
+    "url"         : "https://github.com/KhronosGroup/Vulkan-Tools",
+    "deps_file"   : "scripts/gn/DEPS",
+    "managed"     : False,
+    "custom_deps" : {
+    },
+    "custom_vars": {},
+  },
+]
+EOF
+gclient sync
+
diff --git a/tools/Vulkan-Tools/scripts/known_good.json b/tools/Vulkan-Tools/scripts/known_good.json
new file mode 100644
index 00000000..14e6f5b8
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/known_good.json
@@ -0,0 +1,79 @@
+{
+    "repos": [
+        {
+            "name": "Vulkan-Headers",
+            "api": "vulkan",
+            "url": "https://github.com/KhronosGroup/Vulkan-Headers.git",
+            "sub_dir": "Vulkan-Headers",
+            "build_dir": "Vulkan-Headers/build",
+            "install_dir": "Vulkan-Headers/build/install",
+            "commit": "v1.4.347"
+        },
+        {
+            "name": "MoltenVK",
+            "url": "https://github.com/KhronosGroup/MoltenVK.git",
+            "sub_dir": "MoltenVK",
+            "build_dir": "MoltenVK",
+            "install_dir": "MoltenVK",
+            "commit": "v1.4.1",
+            "custom_build": [
+                "./fetchDependencies --macos",
+                "xcodebuild -project MoltenVKPackaging.xcodeproj GCC_PREPROCESSOR_DEFINITIONS='$GCC_PREPROCESSOR_DEFINITIONS MVK_CONFIG_LOG_LEVEL=1' -scheme \"MoltenVK Package (macOS only)\" build"
+            ],
+            "build_step": "custom",
+            "build_platforms": [
+                "darwin"
+            ]
+        },
+        {
+            "name": "googletest",
+            "url": "https://github.com/google/googletest.git",
+            "sub_dir": "googletest",
+            "build_dir": "googletest/build",
+            "install_dir": "googletest/build/install",
+            "cmake_options": [
+                "-DBUILD_GMOCK=OFF",
+                "-Dgtest_force_shared_crt=ON",
+                "-DBUILD_SHARED_LIBS=OFF"
+            ],
+            "build_platforms": [
+                "windows",
+                "linux",
+                "darwin"
+            ],
+            "commit": "v1.14.0",
+            "optional": [
+                "tests"
+            ]
+        },
+        {
+            "name": "Vulkan-Loader",
+            "api": "vulkan",
+            "url": "https://github.com/KhronosGroup/Vulkan-Loader.git",
+            "sub_dir": "Vulkan-Loader",
+            "build_dir": "Vulkan-Loader/build",
+            "install_dir": "Vulkan-Loader/build/install",
+            "cmake_options": [
+                "-DLOADER_USE_UNSAFE_FILE_SEARCH=ON"
+            ],
+            "commit": "v1.4.347",
+            "build_platforms": [
+                "windows",
+                "linux",
+                "darwin"
+            ],
+            "deps": [
+                {
+                    "var_name": "VULKAN_HEADERS_INSTALL_DIR",
+                    "repo_name": "Vulkan-Headers"
+                }
+            ]
+        }
+    ],
+    "install_names": {
+        "Vulkan-Headers": "VULKAN_HEADERS_INSTALL_DIR",
+        "MoltenVK": "MOLTENVK_REPO_ROOT",
+        "googletest": "GOOGLETEST_INSTALL_DIR",
+        "Vulkan-Loader": "VULKAN_LOADER_INSTALL_DIR"
+    }
+}
diff --git a/tools/Vulkan-Tools/scripts/kvt_genvk.py b/tools/Vulkan-Tools/scripts/kvt_genvk.py
new file mode 100644
index 00000000..868cc3fb
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/kvt_genvk.py
@@ -0,0 +1,416 @@
+#!/usr/bin/python3
+#
+# Copyright (c) 2013-2025 The Khronos Group Inc.
+# Copyright (c) 2023-2025 RasterGrid Kft.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import pdb
+import sys
+import time
+import os
+
+# Simple timer functions
+startTime = None
+
+
+def startTimer(timeit):
+    global startTime
+    if timeit:
+        startTime = time.process_time()
+
+
+def endTimer(timeit, msg):
+    global startTime
+    if timeit:
+        endTime = time.process_time()
+        write(msg, endTime - startTime, file=sys.stderr)
+        startTime = None
+
+# Turn a list of strings into a regexp string matching exactly those strings
+
+
+def makeREstring(list, default=None):
+    if len(list) > 0 or default is None:
+        return '^(' + '|'.join(list) + ')$'
+    else:
+        return default
+
+# Returns a directory of [ generator function, generator options ] indexed
+# by specified short names. The generator options incorporate the following
+# parameters:
+#
+# args is an parsed argument object; see below for the fields that are used.
+
+
+def makeGenOpts(args):
+    global genOpts
+    genOpts = {}
+
+    # API to generate sources for
+    apiname = args.api
+
+    # Default class of extensions to include, or None
+    if args.defaultExtensions is not None:
+        defaultExtensions = args.defaultExtensions
+    else:
+        defaultExtensions = apiname
+
+    # Additional extensions to include (list of extensions)
+    extensions = args.extension
+
+    # Extensions to remove (list of extensions)
+    removeExtensions = args.removeExtensions
+
+    # Extensions to emit (list of extensions)
+    emitExtensions = args.emitExtensions
+
+    # Features to include (list of features)
+    features = args.feature
+
+    # Whether to disable inclusion protect in headers
+    protect = args.protect
+
+    # Output target directory
+    directory = args.directory
+
+    # Path to generated files, particularly api.py
+    genpath = args.genpath
+
+    # Descriptive names for various regexp patterns used to select
+    # versions and extensions
+    allFeatures = allExtensions = '.*'
+    noFeatures = noExtensions = None
+
+    # Turn lists of names/patterns into matching regular expressions
+    addExtensionsPat = makeREstring(extensions, None)
+    removeExtensionsPat = makeREstring(removeExtensions, None)
+    emitExtensionsPat = makeREstring(emitExtensions, allExtensions)
+    featuresPat = makeREstring(features, allFeatures)
+
+    # Copyright text prefixing all headers (list of strings).
+    prefixStrings = [
+        '/*',
+        '** Copyright (c) 2015-2025 The Khronos Group Inc.',
+        '**',
+        '** Licensed under the Apache License, Version 2.0 (the "License");',
+        '** you may not use this file except in compliance with the License.',
+        '** You may obtain a copy of the License at',
+        '**',
+        '**     http://www.apache.org/licenses/LICENSE-2.0',
+        '**',
+        '** Unless required by applicable law or agreed to in writing, software',
+        '** distributed under the License is distributed on an "AS IS" BASIS,',
+        '** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.',
+        '** See the License for the specific language governing permissions and',
+        '** limitations under the License.',
+        '*/',
+        ''
+    ]
+
+    # Text specific to Vulkan headers
+    vkPrefixStrings = [
+        '/*',
+        '** This header is generated from the Khronos Vulkan XML API Registry.',
+        '**',
+        '*/',
+        ''
+    ]
+
+    # Defaults for generating re-inclusion protection wrappers (or not)
+    protectFeature = protect
+
+    # An API style conventions object
+    conventions = VulkanConventions()
+
+    # Helper file generator options for typemap_helper.h
+    genOpts['vk_typemap_helper.h'] = [
+        HelperFileOutputGenerator,
+        HelperFileOutputGeneratorOptions(
+            conventions=conventions,
+            filename='vk_typemap_helper.h',
+            directory=directory,
+            genpath=None,
+            apiname=apiname,
+            profile=None,
+            versions=featuresPat,
+            emitversions=featuresPat,
+            defaultExtensions=defaultExtensions,
+            addExtensions=addExtensionsPat,
+            removeExtensions=removeExtensionsPat,
+            emitExtensions=emitExtensionsPat,
+            prefixText=prefixStrings + vkPrefixStrings,
+            protectFeature=False,
+            apicall='VKAPI_ATTR ',
+            apientry='VKAPI_CALL ',
+            apientryp='VKAPI_PTR *',
+            alignFuncParam=48,
+            expandEnumerants=False,
+            helper_file_type='typemap_helper_header')
+    ]
+
+    # Options for mock ICD header
+    genOpts['function_declarations.h'] = [
+        MockICDOutputGenerator,
+        MockICDGeneratorOptions(
+            conventions=conventions,
+            filename='function_declarations.h',
+            directory=directory,
+            genpath=None,
+            apiname=apiname,
+            profile=None,
+            versions=featuresPat,
+            emitversions=featuresPat,
+            defaultExtensions=defaultExtensions,
+            addExtensions=addExtensionsPat,
+            removeExtensions=removeExtensionsPat,
+            emitExtensions=emitExtensionsPat,
+            prefixText=prefixStrings + vkPrefixStrings,
+            protectFeature=False,
+            apicall='VKAPI_ATTR ',
+            apientry='VKAPI_CALL ',
+            apientryp='VKAPI_PTR *',
+            alignFuncParam=48,
+            expandEnumerants=False,
+            helper_file_type='mock_icd_function_declaration_implementation')
+    ]
+
+    # Options for mock ICD cpp
+    genOpts['function_definitions.h'] = [
+        MockICDOutputGenerator,
+        MockICDGeneratorOptions(
+            conventions=conventions,
+            filename='function_definitions.h',
+            directory=directory,
+            genpath=None,
+            apiname=apiname,
+            profile=None,
+            versions=featuresPat,
+            emitversions=featuresPat,
+            defaultExtensions=defaultExtensions,
+            addExtensions=addExtensionsPat,
+            removeExtensions=removeExtensionsPat,
+            emitExtensions=emitExtensionsPat,
+            prefixText=prefixStrings + vkPrefixStrings,
+            protectFeature=False,
+            apicall='VKAPI_ATTR ',
+            apientry='VKAPI_CALL ',
+            apientryp='VKAPI_PTR *',
+            alignFuncParam=48,
+            expandEnumerants=False,
+            helper_file_type='mock_icd_function_definition_implementation')
+    ]
+
+    # Options for vulkaninfo.hpp
+    genOpts['vulkaninfo.hpp'] = [
+        VulkanInfoGenerator,
+        VulkanInfoGeneratorOptions(
+            conventions=conventions,
+            filename='vulkaninfo.hpp',
+            directory=directory,
+            genpath=None,
+            apiname=apiname,
+            profile=None,
+            versions=featuresPat,
+            emitversions=featuresPat,
+            defaultExtensions=defaultExtensions,
+            addExtensions=addExtensionsPat,
+            removeExtensions=removeExtensionsPat,
+            emitExtensions=emitExtensionsPat,
+            prefixText=prefixStrings + vkPrefixStrings,
+            protectFeature=False,
+            apicall='VKAPI_ATTR ',
+            apientry='VKAPI_CALL ',
+            apientryp='VKAPI_PTR *',
+            alignFuncParam=48,
+            expandEnumerants=False,
+            registryFile=args.registry)
+    ]
+
+
+# Generate a target based on the options in the matching genOpts{} object.
+# This is encapsulated in a function so it can be profiled and/or timed.
+# The args parameter is an parsed argument object containing the following
+# fields that are used:
+#   target - target to generate
+#   directory - directory to generate it in
+#   protect - True if re-inclusion wrappers should be created
+#   extensions - list of additional extensions to include in generated
+#   interfaces
+def genTarget(args):
+    global genOpts
+
+    # Create generator options with specified parameters
+    makeGenOpts(args)
+
+    if (args.target in genOpts.keys()):
+        createGenerator = genOpts[args.target][0]
+        options = genOpts[args.target][1]
+
+        if not args.quiet:
+            write('* Building', options.filename, file=sys.stderr)
+            write('* options.apiname           =', options.apiname, file=sys.stderr)
+            write('* options.versions          =', options.versions, file=sys.stderr)
+            write('* options.emitversions      =', options.emitversions, file=sys.stderr)
+            write('* options.defaultExtensions =', options.defaultExtensions, file=sys.stderr)
+            write('* options.addExtensions     =', options.addExtensions, file=sys.stderr)
+            write('* options.removeExtensions  =', options.removeExtensions, file=sys.stderr)
+            write('* options.emitExtensions    =', options.emitExtensions, file=sys.stderr)
+
+        gen = createGenerator(errFile=errWarn,
+                              warnFile=errWarn,
+                              diagFile=diag)
+        if not args.quiet:
+            write('* Generated', options.filename, file=sys.stderr)
+        return (gen, options)
+    else:
+        write('No generator options for unknown target:',
+              args.target, file=sys.stderr)
+        return none
+
+# -feature name
+# -extension name
+# For both, "name" may be a single name, or a space-separated list
+# of names, or a regular expression.
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('-api', action='store',
+                        default='vulkan',
+                        choices=['vulkan', 'vulkansc'],
+                        help='Specify API name to generate')
+    parser.add_argument('-defaultExtensions', action='store',
+                        default=None,
+                        help='Specify a single class of extensions to add to targets')
+    parser.add_argument('-directory', action='store', default='.',
+                        help='Specify where the built file is place')
+    parser.add_argument('-extension', action='append',
+                        default=[],
+                        help='Specify an extension or extensions to add to targets')
+    parser.add_argument('-removeExtensions', action='append',
+                        default=[],
+                        help='Specify an extension or extensions to remove from targets')
+    parser.add_argument('-emitExtensions', action='append',
+                        default=[],
+                        help='Specify an extension or extensions to emit in targets')
+    parser.add_argument('-feature', action='append',
+                        default=[],
+                        help='Specify a core API feature name or names to add to targets')
+    parser.add_argument('-debug', action='store_true',
+                        help='Enable debugging')
+    parser.add_argument('-dump', action='store_true',
+                        help='Enable dump to stderr')
+    parser.add_argument('-diagfile', action='store',
+                        default=None,
+                        help='Write diagnostics to specified file')
+    parser.add_argument('-errfile', action='store',
+                        default=None,
+                        help='Write errors and warnings to specified file instead of stderr')
+    parser.add_argument('-noprotect', dest='protect', action='store_false',
+                        help='Disable inclusion protection in output headers')
+    parser.add_argument('-profile', action='store_true',
+                        help='Enable profiling')
+    parser.add_argument('-registry', action='store',
+                        default='vk.xml',
+                        help='Use specified registry file instead of vk.xml')
+    parser.add_argument('-time', action='store_true',
+                        help='Enable timing')
+    parser.add_argument('-validate', action='store_true',
+                        help='Enable XML group validation')
+    parser.add_argument('-genpath', action='store', default='gen',
+                        help='Path to generated files')
+    parser.add_argument('-o', action='store', dest='directory',
+                        default='.',
+                        help='Create target and related files in specified directory')
+    parser.add_argument('target', metavar='target', nargs='?',
+                        help='Specify target')
+    parser.add_argument('-quiet', action='store_true', default=True,
+                        help='Suppress script output during normal execution.')
+    parser.add_argument('-verbose', action='store_false', dest='quiet', default=True,
+                        help='Enable script output during normal execution.')
+
+    # This argument tells us where to load the script from the Vulkan-Headers registry
+    parser.add_argument('-scripts', action='store',
+                        help='Find additional scripts in this directory')
+
+    args = parser.parse_args()
+
+    # default scripts path to be same as registry
+    if not args.scripts:
+        args.scripts = os.path.dirname(args.registry)
+
+    scripts_directory_path = os.path.dirname(os.path.abspath(__file__))
+    registry_headers_path = os.path.join(scripts_directory_path, args.scripts)
+    sys.path.insert(0, registry_headers_path)
+
+    from reg import *
+    from generator import write
+    from cgenerator import CGeneratorOptions, COutputGenerator
+
+    # Generator Modifications
+    from generators.mock_icd_generator import MockICDGeneratorOptions, MockICDOutputGenerator
+    from generators.vulkan_tools_helper_file_generator import HelperFileOutputGenerator, HelperFileOutputGeneratorOptions
+    from generators.vulkaninfo_generator import VulkanInfoGenerator, VulkanInfoGeneratorOptions
+    # Temporary workaround for vkconventions python2 compatibility
+    import abc
+    abc.ABC = abc.ABCMeta('ABC', (object,), {})
+    from vkconventions import VulkanConventions
+
+    # This splits arguments which are space-separated lists
+    args.feature = [name for arg in args.feature for name in arg.split()]
+    args.extension = [name for arg in args.extension for name in arg.split()]
+
+    # create error/warning & diagnostic files
+    if (args.errfile):
+        errWarn = open(args.errfile, 'w', encoding='utf-8')
+    else:
+        errWarn = sys.stderr
+
+    if (args.diagfile):
+        diag = open(args.diagfile, 'w', encoding='utf-8')
+    else:
+        diag = None
+
+    # Create the API generator & generator options
+    (gen, options) = genTarget(args)
+
+    # Create the registry object with the specified generator and generator
+    # options. The options are set before XML loading as they may affect it.
+    reg = Registry(gen, options)
+
+    # Parse the specified registry XML into an ElementTree object
+    startTimer(args.time)
+    tree = etree.parse(args.registry)
+    endTimer(args.time, '* Time to make ElementTree =')
+
+    # Load the XML tree into the registry object
+    startTimer(args.time)
+    reg.loadElementTree(tree)
+    endTimer(args.time, '* Time to parse ElementTree =')
+
+    if (args.validate):
+        reg.validateGroups()
+
+    if (args.dump):
+        write('* Dumping registry to regdump.txt', file=sys.stderr)
+        reg.dumpReg(filehandle = open('regdump.txt', 'w', encoding='utf-8'))
+
+    # Finally, use the output generator to create the requested target
+    if (args.debug):
+        pdb.run('reg.apiGen()')
+    else:
+        startTimer(args.time)
+        reg.apiGen()
+        endTimer(args.time, '* Time to generate ' + options.filename + ' =')
+        genTarget(args)
diff --git a/tools/Vulkan-Tools/scripts/update_deps.py b/tools/Vulkan-Tools/scripts/update_deps.py
new file mode 100755
index 00000000..7d300865
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/update_deps.py
@@ -0,0 +1,804 @@
+#!/usr/bin/env python3
+
+# Copyright 2017 The Glslang Authors. All rights reserved.
+# Copyright (c) 2018-2023 Valve Corporation
+# Copyright (c) 2018-2023 LunarG, Inc.
+# Copyright (c) 2023-2023 RasterGrid Kft.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This script was heavily leveraged from KhronosGroup/glslang
+# update_glslang_sources.py.
+"""update_deps.py
+
+Get and build dependent repositories using known-good commits.
+
+Purpose
+-------
+
+This program is intended to assist a developer of this repository
+(the "home" repository) by gathering and building the repositories that
+this home repository depend on.  It also checks out each dependent
+repository at a "known-good" commit in order to provide stability in
+the dependent repositories.
+
+Known-Good JSON Database
+------------------------
+
+This program expects to find a file named "known-good.json" in the
+same directory as the program file.  This JSON file is tailored for
+the needs of the home repository by including its dependent repositories.
+
+Program Options
+---------------
+
+See the help text (update_deps.py --help) for a complete list of options.
+
+Program Operation
+-----------------
+
+The program uses the user's current directory at the time of program
+invocation as the location for fetching and building the dependent
+repositories.  The user can override this by using the "--dir" option.
+
+For example, a directory named "build" in the repository's root directory
+is a good place to put the dependent repositories because that directory
+is not tracked by Git. (See the .gitignore file.)  The "external" directory
+may also be a suitable location.
+A user can issue:
+
+$ cd My-Repo
+$ mkdir build
+$ cd build
+$ ../scripts/update_deps.py
+
+or, to do the same thing, but using the --dir option:
+
+$ cd My-Repo
+$ mkdir build
+$ scripts/update_deps.py --dir=build
+
+With these commands, the "build" directory is considered the "top"
+directory where the program clones the dependent repositories.  The
+JSON file configures the build and install working directories to be
+within this "top" directory.
+
+Note that the "dir" option can also specify an absolute path:
+
+$ cd My-Repo
+$ scripts/update_deps.py --dir=/tmp/deps
+
+The "top" dir is then /tmp/deps (Linux filesystem example) and is
+where this program will clone and build the dependent repositories.
+
+Helper CMake Config File
+------------------------
+
+When the program finishes building the dependencies, it writes a file
+named "helper.cmake" to the "top" directory that contains CMake commands
+for setting CMake variables for locating the dependent repositories.
+This helper file can be used to set up the CMake build files for this
+"home" repository.
+
+A complete sequence might look like:
+
+$ git clone git@github.com:My-Group/My-Repo.git
+$ cd My-Repo
+$ mkdir build
+$ cd build
+$ ../scripts/update_deps.py
+$ cmake -C helper.cmake ..
+$ cmake --build .
+
+JSON File Schema
+----------------
+
+There's no formal schema for the "known-good" JSON file, but here is
+a description of its elements.  All elements are required except those
+marked as optional.  Please see the "known_good.json" file for
+examples of all of these elements.
+
+- name
+
+The name of the dependent repository.  This field can be referenced
+by the "deps.repo_name" structure to record a dependency.
+
+- api
+
+The name of the API the dependency is specific to (e.g. "vulkan").
+
+- url
+
+Specifies the URL of the repository.
+Example: https://github.com/KhronosGroup/Vulkan-Loader.git
+
+- sub_dir
+
+The directory where the program clones the repository, relative to
+the "top" directory.
+
+- build_dir
+
+The directory used to build the repository, relative to the "top"
+directory.
+
+- install_dir
+
+The directory used to store the installed build artifacts, relative
+to the "top" directory.
+
+- commit
+
+The commit used to checkout the repository.  This can be a SHA-1
+object name or a refname used with the remote name "origin".
+
+- deps (optional)
+
+An array of pairs consisting of a CMake variable name and a
+repository name to specify a dependent repo and a "link" to
+that repo's install artifacts.  For example:
+
+"deps" : [
+    {
+        "var_name" : "VULKAN_HEADERS_INSTALL_DIR",
+        "repo_name" : "Vulkan-Headers"
+    }
+]
+
+which represents that this repository depends on the Vulkan-Headers
+repository and uses the VULKAN_HEADERS_INSTALL_DIR CMake variable to
+specify the location where it expects to find the Vulkan-Headers install
+directory.
+Note that the "repo_name" element must match the "name" element of some
+other repository in the JSON file.
+
+- prebuild (optional)
+- prebuild_linux (optional)  (For Linux and MacOS)
+- prebuild_windows (optional)
+
+A list of commands to execute before building a dependent repository.
+This is useful for repositories that require the execution of some
+sort of "update" script or need to clone an auxillary repository like
+googletest.
+
+The commands listed in "prebuild" are executed first, and then the
+commands for the specific platform are executed.
+
+- custom_build (optional)
+
+A list of commands to execute as a custom build instead of using
+the built in CMake way of building. Requires "build_step" to be
+set to "custom"
+
+You can insert the following keywords into the commands listed in
+"custom_build" if they require runtime information (like whether the
+build config is "Debug" or "Release").
+
+Keywords:
+{0} reference to a dictionary of repos and their attributes
+{1} reference to the command line arguments set before start
+{2} reference to the CONFIG_MAP value of config.
+
+Example:
+{2} returns the CONFIG_MAP value of config e.g. debug -> Debug
+{1}.config returns the config variable set when you ran update_dep.py
+{0}[Vulkan-Headers][repo_root] returns the repo_root variable from
+                                   the Vulkan-Headers GoodRepo object.
+
+- cmake_options (optional)
+
+A list of options to pass to CMake during the generation phase.
+
+- ci_only (optional)
+
+A list of environment variables where one must be set to "true"
+(case-insensitive) in order for this repo to be fetched and built.
+This list can be used to specify repos that should be built only in CI.
+
+- build_step (optional)
+
+Specifies if the dependent repository should be built or not. This can
+have a value of 'build', 'custom',  or 'skip'. The dependent repositories are
+built by default.
+
+- build_platforms (optional)
+
+A list of platforms the repository will be built on.
+Legal options include:
+"windows"
+"linux"
+"darwin"
+"android"
+
+Builds on all platforms by default.
+
+Note
+----
+
+The "sub_dir", "build_dir", and "install_dir" elements are all relative
+to the effective "top" directory.  Specifying absolute paths is not
+supported.  However, the "top" directory specified with the "--dir"
+option can be a relative or absolute path.
+
+"""
+
+import argparse
+import json
+import os
+import os.path
+import subprocess
+import sys
+import platform
+import multiprocessing
+import shlex
+import shutil
+import stat
+import time
+
+KNOWN_GOOD_FILE_NAME = 'known_good.json'
+
+CONFIG_MAP = {
+    'debug': 'Debug',
+    'release': 'Release',
+    'relwithdebinfo': 'RelWithDebInfo',
+    'minsizerel': 'MinSizeRel'
+}
+
+# NOTE: CMake also uses the VERBOSE environment variable. This is intentional.
+VERBOSE = os.getenv("VERBOSE")
+
+DEVNULL = open(os.devnull, 'wb')
+
+
+def on_rm_error( func, path, exc_info):
+    """Error handler for recursively removing a directory. The
+    shutil.rmtree function can fail on Windows due to read-only files.
+    This handler will change the permissions for the file and continue.
+    """
+    os.chmod( path, stat.S_IWRITE )
+    os.unlink( path )
+
+def make_or_exist_dirs(path):
+    "Wrapper for os.makedirs that tolerates the directory already existing"
+    # Could use os.makedirs(path, exist_ok=True) if we drop python2
+    if not os.path.isdir(path):
+        os.makedirs(path)
+
+def command_output(cmd, directory):
+    # Runs a command in a directory and returns its standard output stream.
+    # Captures the standard error stream and prints it an error occurs.
+    # Raises a RuntimeError if the command fails to launch or otherwise fails.
+    if VERBOSE:
+        print('In {d}: {cmd}'.format(d=directory, cmd=cmd))
+
+    result = subprocess.run(cmd, cwd=directory, capture_output=True, text=True)
+
+    if result.returncode != 0:
+        print(f'{result.stderr}', file=sys.stderr)
+        raise RuntimeError(f'Failed to run {cmd} in {directory}')
+
+    if VERBOSE:
+        print(result.stdout)
+    return result.stdout
+
+def run_cmake_command(cmake_cmd):
+    # NOTE: Because CMake is an exectuable that runs executables
+    # stdout/stderr are mixed together. So this combines the outputs
+    # and prints them properly in case there is a non-zero exit code.
+    result = subprocess.run(cmake_cmd, 
+        stdout = subprocess.PIPE,
+        stderr = subprocess.STDOUT,
+        text = True
+    )
+
+    if VERBOSE:
+        print(result.stdout)
+        print(f"CMake command: {cmake_cmd} ", flush=True)
+
+    if result.returncode != 0:
+        print(result.stdout, file=sys.stderr)
+        sys.exit(result.returncode)
+
+def escape(path):
+    return path.replace('\\', '/')
+
+class GoodRepo(object):
+    """Represents a repository at a known-good commit."""
+
+    def __init__(self, json, args):
+        """Initializes this good repo object.
+
+        Args:
+        'json':  A fully populated JSON object describing the repo.
+        'args':  Results from ArgumentParser
+        """
+        self._json = json
+        self._args = args
+        # Required JSON elements
+        self.name = json['name']
+        self.url = json['url']
+        self.sub_dir = json['sub_dir']
+        self.commit = json['commit']
+        # Optional JSON elements
+        self.build_dir = None
+        self.install_dir = None
+        if json.get('build_dir'):
+            self.build_dir = os.path.normpath(json['build_dir'])
+        if json.get('install_dir'):
+            self.install_dir = os.path.normpath(json['install_dir'])
+        self.deps = json['deps'] if ('deps' in json) else []
+        self.prebuild = json['prebuild'] if ('prebuild' in json) else []
+        self.prebuild_linux = json['prebuild_linux'] if (
+            'prebuild_linux' in json) else []
+        self.prebuild_windows = json['prebuild_windows'] if (
+            'prebuild_windows' in json) else []
+        self.custom_build = json['custom_build'] if ('custom_build' in json) else []
+        self.cmake_options = json['cmake_options'] if (
+            'cmake_options' in json) else []
+        self.ci_only = json['ci_only'] if ('ci_only' in json) else []
+        self.build_step = json['build_step'] if ('build_step' in json) else 'build'
+        self.build_platforms = json['build_platforms'] if ('build_platforms' in json) else []
+        self.optional = set(json.get('optional', []))
+        self.api = json['api'] if ('api' in json) else None
+        # Absolute paths for a repo's directories
+        dir_top = os.path.abspath(args.dir)
+        self.repo_dir = os.path.join(dir_top, self.sub_dir)
+        if self.build_dir:
+            self.build_dir = os.path.join(dir_top, self.build_dir)
+        if self.install_dir:
+            self.install_dir = os.path.join(dir_top, self.install_dir)
+
+        # By default the target platform is the host platform.
+        target_platform = platform.system().lower()
+        # However, we need to account for cross-compiling.
+        for cmake_var in self._args.cmake_var:
+            if "android.toolchain.cmake" in cmake_var:
+                target_platform = 'android'
+
+        self.on_build_platform = False
+        if self.build_platforms == [] or target_platform in self.build_platforms:
+            self.on_build_platform = True
+
+    def Clone(self, retries=10, retry_seconds=60):
+        if VERBOSE:
+            print('Cloning {n} into {d}'.format(n=self.name, d=self.repo_dir))
+        for retry in range(retries):
+            make_or_exist_dirs(self.repo_dir)
+            try:
+                command_output(['git', 'clone', self.url, '.'], self.repo_dir)
+                # If we get here, we didn't raise an error
+                return
+            except RuntimeError as e:
+                print("Error cloning on iteration {}/{}: {}".format(retry + 1, retries, e))
+                if retry + 1 < retries:
+                    if retry_seconds > 0:
+                        print("Waiting {} seconds before trying again".format(retry_seconds))
+                        time.sleep(retry_seconds)
+                    if os.path.isdir(self.repo_dir):
+                        print("Removing old tree {}".format(self.repo_dir))
+                        shutil.rmtree(self.repo_dir, onerror=on_rm_error)
+                    continue
+
+                # If we get here, we've exhausted our retries.
+                print("Failed to clone {} on all retries.".format(self.url))
+                raise e
+
+    def Fetch(self, retries=10, retry_seconds=60):
+        for retry in range(retries):
+            try:
+                command_output(['git', 'fetch', 'origin'], self.repo_dir)
+                # if we get here, we didn't raise an error, and we're done
+                return
+            except RuntimeError as e:
+                print("Error fetching on iteration {}/{}: {}".format(retry + 1, retries, e))
+                if retry + 1 < retries:
+                    if retry_seconds > 0:
+                        print("Waiting {} seconds before trying again".format(retry_seconds))
+                        time.sleep(retry_seconds)
+                    continue
+
+                # If we get here, we've exhausted our retries.
+                print("Failed to fetch {} on all retries.".format(self.url))
+                raise e
+
+    def Checkout(self):
+        if VERBOSE:
+            print('Checking out {n} in {d}'.format(n=self.name, d=self.repo_dir))
+
+        if os.path.exists(os.path.join(self.repo_dir, '.git')):
+            url_changed = command_output(['git', 'config', '--get', 'remote.origin.url'], self.repo_dir).strip() != self.url
+        else:
+            url_changed = False
+
+        if self._args.do_clean_repo or url_changed:
+            if os.path.isdir(self.repo_dir):
+                if VERBOSE:
+                    print('Clearing directory {d}'.format(d=self.repo_dir))
+                shutil.rmtree(self.repo_dir, onerror = on_rm_error)
+        if not os.path.exists(os.path.join(self.repo_dir, '.git')):
+            self.Clone()
+        self.Fetch()
+        if len(self._args.ref):
+            command_output(['git', 'checkout', self._args.ref], self.repo_dir)
+        else:
+            command_output(['git', 'checkout', self.commit], self.repo_dir)
+
+        if VERBOSE:
+            print(command_output(['git', 'status'], self.repo_dir))
+
+    def CustomPreProcess(self, cmd_str, repo_dict):
+        return cmd_str.format(repo_dict, self._args, CONFIG_MAP[self._args.config])
+
+    def PreBuild(self):
+        """Execute any prebuild steps from the repo root"""
+        for p in self.prebuild:
+            command_output(shlex.split(p), self.repo_dir)
+        if platform.system() == 'Linux' or platform.system() == 'Darwin':
+            for p in self.prebuild_linux:
+                command_output(shlex.split(p), self.repo_dir)
+        if platform.system() == 'Windows':
+            for p in self.prebuild_windows:
+                command_output(shlex.split(p), self.repo_dir)
+
+    def CustomBuild(self, repo_dict):
+        """Execute any custom_build steps from the repo root"""
+        for p in self.custom_build:
+            cmd = self.CustomPreProcess(p, repo_dict)
+            command_output(shlex.split(cmd), self.repo_dir)
+
+    def CMakeConfig(self, repos):
+        """Build CMake command for the configuration phase and execute it"""
+        if self._args.do_clean_build:
+            if os.path.isdir(self.build_dir):
+                shutil.rmtree(self.build_dir, onerror=on_rm_error)
+        if self._args.do_clean_install:
+            if os.path.isdir(self.install_dir):
+                shutil.rmtree(self.install_dir, onerror=on_rm_error)
+
+        # Create and change to build directory
+        make_or_exist_dirs(self.build_dir)
+        os.chdir(self.build_dir)
+
+        cmake_cmd = [
+            'cmake', self.repo_dir,
+            '-DCMAKE_INSTALL_PREFIX=' + self.install_dir
+        ]
+
+        # Allow users to pass in arbitrary cache variables
+        for cmake_var in self._args.cmake_var:
+            pieces = cmake_var.split('=', 1)
+            cmake_cmd.append('-D{}={}'.format(pieces[0], pieces[1]))
+
+        # For each repo this repo depends on, generate a CMake variable
+        # definitions for "...INSTALL_DIR" that points to that dependent
+        # repo's install dir.
+        for d in self.deps:
+            dep_commit = [r for r in repos if r.name == d['repo_name']]
+            if len(dep_commit) and dep_commit[0].on_build_platform:
+                cmake_cmd.append('-D{var_name}={install_dir}'.format(
+                    var_name=d['var_name'],
+                    install_dir=dep_commit[0].install_dir))
+
+        # Add any CMake options
+        for option in self.cmake_options:
+            cmake_cmd.append(escape(option.format(**self.__dict__)))
+
+        # Set build config for single-configuration generators (this is a no-op on multi-config generators)
+        cmake_cmd.append(f'-D CMAKE_BUILD_TYPE={CONFIG_MAP[self._args.config]}')
+
+        # Use the CMake -A option to select the platform architecture
+        # without needing a Visual Studio generator.
+        if platform.system() == 'Windows' and not self._args.generator in ["Ninja", "MinGW Makefiles"]:
+            cmake_cmd.append('-A')
+            if self._args.arch.lower() == '64' or self._args.arch == 'x64' or self._args.arch == 'win64':
+                cmake_cmd.append('x64')
+            elif self._args.arch == 'arm64':
+                cmake_cmd.append('arm64')
+            else:
+                cmake_cmd.append('Win32')
+
+        # Apply a generator, if one is specified.  This can be used to supply
+        # a specific generator for the dependent repositories to match
+        # that of the main repository.
+        if self._args.generator is not None:
+            cmake_cmd.extend(['-G', self._args.generator])
+
+        # Removes warnings related to unused CLI
+        # EX: Setting CMAKE_CXX_COMPILER for a C project
+        if not VERBOSE:
+            cmake_cmd.append("--no-warn-unused-cli")
+
+        run_cmake_command(cmake_cmd)
+
+    def CMakeBuild(self):
+        """Build CMake command for the build phase and execute it"""
+        cmake_cmd = ['cmake', '--build', self.build_dir, '--target', 'install', '--config', CONFIG_MAP[self._args.config]]
+        if self._args.do_clean:
+            cmake_cmd.append('--clean-first')
+
+        # Xcode / Ninja are parallel by default.
+        if self._args.generator != "Ninja" or self._args.generator != "Xcode":
+            cmake_cmd.append('--parallel')
+            cmake_cmd.append(format(multiprocessing.cpu_count()))
+
+        run_cmake_command(cmake_cmd)
+
+    def Build(self, repos, repo_dict):
+        """Build the dependent repo and time how long it took"""
+        if VERBOSE:
+            print('Building {n} in {d}'.format(n=self.name, d=self.repo_dir))
+            print('Build dir = {b}'.format(b=self.build_dir))
+            print('Install dir = {i}\n'.format(i=self.install_dir))
+
+        start = time.time()
+
+        # Run any prebuild commands
+        self.PreBuild()
+
+        if self.build_step == 'custom':
+            self.CustomBuild(repo_dict)
+            return
+
+        # Build and execute CMake command for creating build files
+        self.CMakeConfig(repos)
+
+        # Build and execute CMake command for the build
+        self.CMakeBuild()
+
+        total_time = time.time() - start
+
+        print(f"Installed {self.name} ({self.commit}) in {total_time} seconds", flush=True)
+
+    def IsOptional(self, opts):
+        return len(self.optional.intersection(opts)) > 0
+
+def GetGoodRepos(args):
+    """Returns the latest list of GoodRepo objects.
+
+    The known-good file is expected to be in the same
+    directory as this script unless overridden by the 'known_good_dir'
+    parameter.
+    """
+    if args.known_good_dir:
+        known_good_file = os.path.join( os.path.abspath(args.known_good_dir),
+            KNOWN_GOOD_FILE_NAME)
+    else:
+        known_good_file = os.path.join(
+            os.path.dirname(os.path.abspath(__file__)), KNOWN_GOOD_FILE_NAME)
+    with open(known_good_file) as known_good:
+        return [
+            GoodRepo(repo, args)
+            for repo in json.loads(known_good.read())['repos']
+        ]
+
+
+def GetInstallNames(args):
+    """Returns the install names list.
+
+    The known-good file is expected to be in the same
+    directory as this script unless overridden by the 'known_good_dir'
+    parameter.
+    """
+    if args.known_good_dir:
+        known_good_file = os.path.join(os.path.abspath(args.known_good_dir),
+            KNOWN_GOOD_FILE_NAME)
+    else:
+        known_good_file = os.path.join(
+            os.path.dirname(os.path.abspath(__file__)), KNOWN_GOOD_FILE_NAME)
+    with open(known_good_file) as known_good:
+        install_info = json.loads(known_good.read())
+        if install_info.get('install_names'):
+            return install_info['install_names']
+        else:
+            return None
+
+
+def CreateHelper(args, repos, filename):
+    """Create a CMake config helper file.
+
+    The helper file is intended to be used with 'cmake -C <file>'
+    to build this home repo using the dependencies built by this script.
+
+    The install_names dictionary represents the CMake variables used by the
+    home repo to locate the install dirs of the dependent repos.
+    This information is baked into the CMake files of the home repo and so
+    this dictionary is kept with the repo via the json file.
+    """
+    install_names = GetInstallNames(args)
+    with open(filename, 'w') as helper_file:
+        for repo in repos:
+            # If the repo has an API tag and that does not match
+            # the target API then skip it
+            if repo.api is not None and repo.api != args.api:
+                continue
+            if install_names and repo.name in install_names and repo.on_build_platform:
+                helper_file.write('set({var} "{dir}" CACHE STRING "")\n'
+                                  .format(
+                                      var=install_names[repo.name],
+                                      dir=escape(repo.install_dir)))
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Get and build dependent repos at known-good commits')
+    parser.add_argument(
+        '--known_good_dir',
+        dest='known_good_dir',
+        help="Specify directory for known_good.json file.")
+    parser.add_argument(
+        '--dir',
+        dest='dir',
+        default='.',
+        help="Set target directory for repository roots. Default is \'.\'.")
+    parser.add_argument(
+        '--ref',
+        dest='ref',
+        default='',
+        help="Override 'commit' with git reference. E.g., 'origin/main'")
+    parser.add_argument(
+        '--no-build',
+        dest='do_build',
+        action='store_false',
+        help=
+        "Clone/update repositories and generate build files without performing compilation",
+        default=True)
+    parser.add_argument(
+        '--clean',
+        dest='do_clean',
+        action='store_true',
+        help="Clean files generated by compiler and linker before building",
+        default=False)
+    parser.add_argument(
+        '--clean-repo',
+        dest='do_clean_repo',
+        action='store_true',
+        help="Delete repository directory before building",
+        default=False)
+    parser.add_argument(
+        '--clean-build',
+        dest='do_clean_build',
+        action='store_true',
+        help="Delete build directory before building",
+        default=False)
+    parser.add_argument(
+        '--clean-install',
+        dest='do_clean_install',
+        action='store_true',
+        help="Delete install directory before building",
+        default=False)
+    parser.add_argument(
+        '--skip-existing-install',
+        dest='skip_existing_install',
+        action='store_true',
+        help="Skip build if install directory exists",
+        default=False)
+    parser.add_argument(
+        '--arch',
+        dest='arch',
+        choices=['32', '64', 'x86', 'x64', 'win32', 'win64', 'arm64'],
+        type=str.lower,
+        help="Set build files architecture (Visual Studio Generator Only)",
+        default='64')
+    parser.add_argument(
+        '--config',
+        dest='config',
+        choices=['debug', 'release', 'relwithdebinfo', 'minsizerel'],
+        type=str.lower,
+        help="Set build files configuration",
+        default='debug')
+    parser.add_argument(
+        '--api',
+        dest='api',
+        default='vulkan',
+        choices=['vulkan'],
+        help="Target API")
+    parser.add_argument(
+        '--generator',
+        dest='generator',
+        help="Set the CMake generator",
+        default=None)
+    parser.add_argument(
+        '--optional',
+        dest='optional',
+        type=lambda a: set(a.lower().split(',')),
+        help="Comma-separated list of 'optional' resources that may be skipped. Only 'tests' is currently supported as 'optional'",
+        default=set())
+    parser.add_argument(
+        '--cmake_var',
+        dest='cmake_var',
+        action='append',
+        metavar='VAR[=VALUE]',
+        help="Add CMake command line option -D'VAR'='VALUE' to the CMake generation command line; may be used multiple times",
+        default=[])
+
+    args = parser.parse_args()
+    save_cwd = os.getcwd()
+
+    # Create working "top" directory if needed
+    make_or_exist_dirs(args.dir)
+    abs_top_dir = os.path.abspath(args.dir)
+
+    repos = GetGoodRepos(args)
+    repo_dict = {}
+
+    print('Starting builds in {d}'.format(d=abs_top_dir))
+    for repo in repos:
+        # If the repo has an API tag and that does not match
+        # the target API then skip it
+        if repo.api is not None and repo.api != args.api:
+            continue
+
+        # If the repo has a platform whitelist, skip the repo
+        # unless we are building on a whitelisted platform.
+        if not repo.on_build_platform:
+            continue
+
+        # Skip building the repo if its install directory already exists
+        # and requested via an option.  This is useful for cases where the
+        # install directory is restored from a cache that is known to be up
+        # to date.
+        if args.skip_existing_install and os.path.isdir(repo.install_dir):
+            print('Skipping build for repo {n} due to existing install directory'.format(n=repo.name))
+            continue
+
+        # Skip test-only repos if the --tests option was not passed in
+        if repo.IsOptional(args.optional):
+            continue
+
+        field_list = ('url',
+                      'sub_dir',
+                      'commit',
+                      'build_dir',
+                      'install_dir',
+                      'deps',
+                      'prebuild',
+                      'prebuild_linux',
+                      'prebuild_windows',
+                      'custom_build',
+                      'cmake_options',
+                      'ci_only',
+                      'build_step',
+                      'build_platforms',
+                      'repo_dir',
+                      'on_build_platform')
+        repo_dict[repo.name] = {field: getattr(repo, field) for field in field_list}
+
+        # If the repo has a CI whitelist, skip the repo unless
+        # one of the CI's environment variable is set to true.
+        if len(repo.ci_only):
+            do_build = False
+            for env in repo.ci_only:
+                if env not in os.environ:
+                    continue
+                if os.environ[env].lower() == 'true':
+                    do_build = True
+                    break
+            if not do_build:
+                continue
+
+        # Clone/update the repository
+        repo.Checkout()
+
+        # Build the repository
+        if args.do_build and repo.build_step != 'skip':
+            repo.Build(repos, repo_dict)
+
+    # Need to restore original cwd in order for CreateHelper to find json file
+    os.chdir(save_cwd)
+    CreateHelper(args, repos, os.path.join(abs_top_dir, 'helper.cmake'))
+
+    sys.exit(0)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/tools/Vulkan-Tools/tests/CMakeLists.txt b/tools/Vulkan-Tools/tests/CMakeLists.txt
new file mode 100644
index 00000000..a1b7250f
--- /dev/null
+++ b/tools/Vulkan-Tools/tests/CMakeLists.txt
@@ -0,0 +1,71 @@
+# ~~~
+# Copyright (c) 2023 Valve Corporation
+# Copyright (c) 2023 LunarG, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ~~~
+
+if (ANDROID)
+
+    # Ensure ANativeActivity_onCreate is being exported from vkcube
+    find_program(GNU_NM NAMES nm)
+    if (GNU_NM)
+        add_test(NAME ANativeActivity_onCreate COMMAND ${GNU_NM} --dynamic $<TARGET_FILE:vkcube>)
+        set_tests_properties(ANativeActivity_onCreate
+            PROPERTIES PASS_REGULAR_EXPRESSION "T ANativeActivity_onCreate"
+        )
+    endif()
+
+    return()
+endif()
+
+# Testing isn't supported with mingw
+if (MINGW)
+    return()
+endif()
+
+find_package(VulkanLoader CONFIG)
+
+find_package(GTest REQUIRED CONFIG QUIET)
+
+add_executable(vulkan_tools_tests)
+target_sources(vulkan_tools_tests PRIVATE
+    main.cpp
+    test_common.h
+    icd/mock_icd_tests.cpp
+)
+get_target_property(TEST_SOURCES vulkan_tools_tests SOURCES)
+source_group(TREE "${CMAKE_CURRENT_SOURCE_DIR}" FILES ${TEST_SOURCES})
+
+target_include_directories(vulkan_tools_tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
+target_link_libraries(vulkan_tools_tests GTest::gtest Vulkan::Headers Vulkan::Loader)
+if (WIN32)
+    target_compile_definitions(vulkan_tools_tests PUBLIC -DVK_USE_PLATFORM_WIN32_KHR -DWIN32_LEAN_AND_MEAN -DNOMINMAX)
+endif()
+set_target_properties(vulkan_tools_tests PROPERTIES MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")
+
+# Set the exact path to Mock JSON ICD
+target_compile_definitions(vulkan_tools_tests PRIVATE MOCK_ICD_JSON_MANIFEST_PATH="$<TARGET_FILE_DIR:VkICD_mock_icd>")
+
+if (DEFINED GIT_BRANCH_NAME AND DEFINED GIT_TAG_INFO)
+    target_compile_definitions(vulkan_tools_tests PRIVATE GIT_BRANCH_NAME="${GIT_BRANCH_NAME}" GIT_TAG_INFO="${GIT_TAG_INFO}")
+endif()
+
+if (WIN32)
+    # Copy the loader shared lib (if built) to the test application directory so the test app finds it.
+    add_custom_command(TARGET vulkan_tools_tests POST_BUILD
+                           COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:Vulkan::Loader> $<TARGET_FILE_DIR:vulkan_tools_tests>)
+endif()
+
+include(GoogleTest)
+gtest_discover_tests(vulkan_tools_tests DISCOVERY_TIMEOUT 100)
diff --git a/tools/Vulkan-Tools/tests/README.md b/tools/Vulkan-Tools/tests/README.md
new file mode 100644
index 00000000..0e0798e7
--- /dev/null
+++ b/tools/Vulkan-Tools/tests/README.md
@@ -0,0 +1,34 @@
+## Android
+
+### Running vkcube on Android
+
+```sh
+cd Vulkan-Tools
+
+cd build-android
+
+# Optional
+adb uninstall com.example.VkCube
+
+adb install -r -g --no-incremental bin/VkCube.apk
+
+adb shell am start com.example.VkCube/android.app.NativeActivity
+```
+
+### vulkaninfo on Android
+
+Unlike `vkcube`, `vulkaninfo` doesn't require the extra step of creating an `APK`.
+
+So the following should be enough.
+
+```sh
+cd Vulkan-Tools
+
+scripts/android.py --config Release --app-abi arm64-v8a --app-stl c++_static --clean
+
+adb push build-android/cmake/arm64-v8a/vulkaninfo/vulkaninfo /data/local/tmp
+
+adb shell /data/local/tmp/vulkaninfo --json --output /data/local/tmp/foobar.json
+
+adb pull /data/local/tmp/foobar.json
+```
diff --git a/tools/Vulkan-Tools/tests/icd/mock_icd_tests.cpp b/tools/Vulkan-Tools/tests/icd/mock_icd_tests.cpp
new file mode 100644
index 00000000..06fc124f
--- /dev/null
+++ b/tools/Vulkan-Tools/tests/icd/mock_icd_tests.cpp
@@ -0,0 +1,1199 @@
+/*
+ * Copyright (c) 2023 The Khronos Group Inc.
+ * Copyright (c) 2023 Valve Corporation
+ * Copyright (c) 2023 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "test_common.h"
+
+void setup_mock_icd_env_vars() {
+    // Necessary to point the loader at the mock driver
+    set_environment_var("VK_DRIVER_FILES", MOCK_ICD_JSON_MANIFEST_PATH);
+    // Prevents layers from being loaded at all
+    set_environment_var("VK_LOADER_LAYERS_DISABLE", "~all~");
+}
+
+// Defines a simple context for tests to use.
+// Creates an instance, physical_device, device, and queue
+
+class MockICD : public ::testing::Test {
+  protected:
+    void SetUp() override {
+        setup_mock_icd_env_vars();
+
+        // Create an instance with the latest version & necessary surface extensions
+        VkResult res = VK_SUCCESS;
+        VkApplicationInfo app_info{};
+        app_info.apiVersion = VK_HEADER_VERSION_COMPLETE;
+        VkInstanceCreateInfo instance_create_info{};
+        instance_create_info.pApplicationInfo = &app_info;
+        std::array<const char*, 2> extension_to_enable = {"VK_KHR_surface", "VK_KHR_display"};
+        instance_create_info.enabledExtensionCount = static_cast<uint32_t>(extension_to_enable.size());
+        instance_create_info.ppEnabledExtensionNames = extension_to_enable.data();
+        res = vkCreateInstance(&instance_create_info, nullptr, &instance);
+        ASSERT_EQ(res, VK_SUCCESS);
+        ASSERT_NE(instance, nullptr);
+
+        uint32_t count = 1;
+        res = vkEnumeratePhysicalDevices(instance, &count, &physical_device);
+        ASSERT_EQ(res, VK_SUCCESS);
+        ASSERT_EQ(count, 1);
+        ASSERT_NE(physical_device, nullptr);
+
+        VkDeviceCreateInfo device_create_info{};
+        std::array<const char*, 1> device_extension_to_enable = {"VK_KHR_swapchain"};
+        device_create_info.enabledExtensionCount = static_cast<uint32_t>(device_extension_to_enable.size());
+        device_create_info.ppEnabledExtensionNames = device_extension_to_enable.data();
+        res = vkCreateDevice(physical_device, &device_create_info, nullptr, &device);
+        ASSERT_EQ(res, VK_SUCCESS);
+        ASSERT_NE(device, nullptr);
+
+        vkGetDeviceQueue(device, 0, 0, &queue);
+        ASSERT_NE(queue, nullptr);
+    }
+
+    void TearDown() override {
+        vkDestroyDevice(device, nullptr);
+        vkDestroyInstance(instance, nullptr);
+    }
+
+    VkInstance instance{};
+    VkPhysicalDevice physical_device{};
+    VkDevice device{};
+    VkQueue queue{};
+};
+
+/*
+ * Exercises the following commands:
+ * vkEnumerateInstanceExtensionProperties
+ * vkEnumerateInstanceLayerProperties
+ * vkEnumerateInstanceVersion
+ * vkCreateInstance
+ * vkEnumeratePhysicalDevices
+ * vkEnumeratePhysicalDeviceGroups
+ * vkEnumerateDeviceExtensionProperties
+ * vkGetPhysicalDeviceQueueFamilyProperties
+ * vkGetPhysicalDeviceQueueFamilyProperties2
+ * vkCreateDevice
+ * vkDestroyDevice
+ * vkDestroyInstance
+ * vkGetDeviceQueue
+ * vkGetDeviceQueue2
+ */
+TEST_F(MockICD, InitializationFunctions) {
+    setup_mock_icd_env_vars();
+    VkResult res = VK_SUCCESS;
+    uint32_t count = 0;
+    res = vkEnumerateInstanceExtensionProperties(nullptr, &count, nullptr);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_GT(count, 0);
+    std::vector<VkExtensionProperties> inst_ext_props{count, VkExtensionProperties{}};
+    res = vkEnumerateInstanceExtensionProperties(nullptr, &count, inst_ext_props.data());
+    ASSERT_EQ(res, VK_SUCCESS);
+
+    // Since we disabled layers, count should stay zero
+    count = 0;
+    res = vkEnumerateInstanceLayerProperties(&count, nullptr);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(count, 0);
+
+    uint32_t api_version;
+    res = vkEnumerateInstanceVersion(&api_version);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_GE(api_version, VK_API_VERSION_1_0);
+
+    VkInstanceCreateInfo inst_create_info{};
+    VkInstance instance{};
+    res = vkCreateInstance(&inst_create_info, nullptr, &instance);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_NE(instance, nullptr);
+
+    count = 0;
+    VkPhysicalDevice physical_device;
+    res = vkEnumeratePhysicalDevices(instance, &count, nullptr);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(count, 1);
+
+    res = vkEnumeratePhysicalDevices(instance, &count, &physical_device);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(count, 1);
+    ASSERT_NE(physical_device, nullptr);
+
+    count = 0;
+    res = vkEnumeratePhysicalDeviceGroups(instance, &count, nullptr);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_GT(count, 0);
+
+    VkPhysicalDeviceGroupProperties physical_device_groups;
+    count = 1;
+    res = vkEnumeratePhysicalDeviceGroups(instance, &count, &physical_device_groups);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(count, 1);
+
+    count = 0;
+    res = vkEnumerateDeviceExtensionProperties(physical_device, nullptr, &count, nullptr);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_GT(count, 0);
+    std::vector<VkExtensionProperties> device_ext_props{count, VkExtensionProperties{}};
+    res = vkEnumerateDeviceExtensionProperties(physical_device, nullptr, &count, device_ext_props.data());
+    ASSERT_EQ(res, VK_SUCCESS);
+
+    // Device layers are deprecated, should return number of active layers, which is zero
+    count = 0;
+    res = vkEnumerateDeviceLayerProperties(physical_device, &count, nullptr);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(count, 0);
+    count = 0;
+
+    vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &count, nullptr);
+    ASSERT_EQ(count, 3);
+    VkQueueFamilyProperties queue_family_properties[3] = {};
+    vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &count, queue_family_properties);
+    ASSERT_EQ(count, 3);
+    ASSERT_EQ(queue_family_properties[0].queueFlags, 1 | 2 | 4 | 8 | 16);
+    ASSERT_EQ(queue_family_properties[1].queueFlags, 4 | 16 | 32);
+    ASSERT_EQ(queue_family_properties[2].queueFlags, 4 | 16 | 64);
+    for (uint32_t i = 0; i < count; ++i) {
+        ASSERT_EQ(queue_family_properties[i].queueCount, 1);
+        ASSERT_EQ(queue_family_properties[i].timestampValidBits, 16);
+        ASSERT_EQ(queue_family_properties[i].minImageTransferGranularity.width, 1);
+        ASSERT_EQ(queue_family_properties[i].minImageTransferGranularity.height, 1);
+        ASSERT_EQ(queue_family_properties[i].minImageTransferGranularity.depth, 1);
+    }
+
+    vkGetPhysicalDeviceQueueFamilyProperties2(physical_device, &count, nullptr);
+    ASSERT_EQ(count, 3);
+    VkQueueFamilyProperties2 queue_family_properties2[3] = {};
+    for (uint32_t i = 0; i < count; ++i) {
+        queue_family_properties2[i].sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2;
+    }
+    vkGetPhysicalDeviceQueueFamilyProperties2(physical_device, &count, queue_family_properties2);
+    ASSERT_EQ(count, 3);
+    ASSERT_EQ(queue_family_properties2[0].queueFamilyProperties.queueFlags, 1 | 2 | 4 | 8 | 16);
+    ASSERT_EQ(queue_family_properties2[1].queueFamilyProperties.queueFlags, 4 | 16 | 32);
+    ASSERT_EQ(queue_family_properties2[2].queueFamilyProperties.queueFlags, 4 | 16 | 64);
+    for (uint32_t i = 0; i < count; ++i) {
+        ASSERT_EQ(queue_family_properties2[i].queueFamilyProperties.queueCount, 1);
+        ASSERT_EQ(queue_family_properties2[i].queueFamilyProperties.timestampValidBits, 16);
+        ASSERT_EQ(queue_family_properties2[i].queueFamilyProperties.minImageTransferGranularity.width, 1);
+        ASSERT_EQ(queue_family_properties2[i].queueFamilyProperties.minImageTransferGranularity.height, 1);
+        ASSERT_EQ(queue_family_properties2[i].queueFamilyProperties.minImageTransferGranularity.depth, 1);
+    }
+
+    VkDeviceCreateInfo dev_create_info{};
+    VkDevice device{};
+    res = vkCreateDevice(physical_device, &dev_create_info, nullptr, &device);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_NE(device, nullptr);
+
+    VkQueue queue{};
+    vkGetDeviceQueue(device, 0, 0, &queue);
+    ASSERT_NE(queue, nullptr);
+
+    VkDeviceQueueInfo2 queue_info{};
+    vkGetDeviceQueue2(device, &queue_info, &queue);
+    ASSERT_NE(queue, nullptr);
+
+    vkDestroyDevice(device, nullptr);
+    vkDestroyInstance(instance, nullptr);
+}
+
+/*
+ * Exercises the following commands:
+ * vkCreateCommandPool
+ * vkAllocateCommandBuffers
+ * vkFreeCommandBuffers
+ * vkDestroyCommandPool
+ */
+TEST_F(MockICD, CommandBufferOperations) {
+    VkResult res = VK_SUCCESS;
+    VkCommandPoolCreateInfo command_pool_create_info{};
+    VkCommandPool command_pool;
+    res = vkCreateCommandPool(device, &command_pool_create_info, nullptr, &command_pool);
+    ASSERT_EQ(VK_SUCCESS, res);
+
+    VkCommandBufferAllocateInfo command_buffer_allocate_info{};
+    command_buffer_allocate_info.commandBufferCount = 5;
+    std::array<VkCommandBuffer, 5> command_buffers;
+    res = vkAllocateCommandBuffers(device, &command_buffer_allocate_info, command_buffers.data());
+    ASSERT_EQ(VK_SUCCESS, res);
+    for (const auto& command_buffer : command_buffers) {
+        ASSERT_NE(nullptr, command_buffer);
+    }
+
+    vkFreeCommandBuffers(device, command_pool, 5, command_buffers.data());
+
+    vkDestroyCommandPool(device, command_pool, nullptr);
+}
+
+VkResult create_surface(VkInstance instance, VkSurfaceKHR& surface) {
+    VkDisplaySurfaceCreateInfoKHR surf_create_info{VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR};
+    return vkCreateDisplayPlaneSurfaceKHR(instance, &surf_create_info, nullptr, &surface);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceSurfacePresentModesKHR) {
+    VkResult res = VK_SUCCESS;
+    VkSurfaceKHR surface{};
+    res = create_surface(instance, surface);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_NE(surface, VK_NULL_HANDLE);
+    uint32_t count = 0;
+    std::array<VkPresentModeKHR, 6> present_modes{};
+    res = vkGetPhysicalDeviceSurfacePresentModesKHR(physical_device, surface, &count, nullptr);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(count, present_modes.size());
+    vkGetPhysicalDeviceSurfacePresentModesKHR(physical_device, surface, &count, present_modes.data());
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(present_modes[0], VK_PRESENT_MODE_IMMEDIATE_KHR);
+    ASSERT_EQ(present_modes[1], VK_PRESENT_MODE_MAILBOX_KHR);
+    ASSERT_EQ(present_modes[2], VK_PRESENT_MODE_FIFO_KHR);
+    ASSERT_EQ(present_modes[3], VK_PRESENT_MODE_FIFO_RELAXED_KHR);
+    ASSERT_EQ(present_modes[4], VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR);
+    ASSERT_EQ(present_modes[5], VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR);
+    vkDestroySurfaceKHR(instance, surface, nullptr);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceSurfaceFormatsKHR) {
+    VkResult res = VK_SUCCESS;
+    VkSurfaceKHR surface{};
+    res = create_surface(instance, surface);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_NE(surface, VK_NULL_HANDLE);
+    uint32_t count = 0;
+    std::array<VkSurfaceFormatKHR, 2> surface_formats{};
+    res = vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, surface, &count, nullptr);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(count, surface_formats.size());
+    vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, surface, &count, surface_formats.data());
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(surface_formats[0].format, VK_FORMAT_B8G8R8A8_UNORM);
+    ASSERT_EQ(surface_formats[0].colorSpace, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR);
+    ASSERT_EQ(surface_formats[1].format, VK_FORMAT_R8G8B8A8_UNORM);
+    ASSERT_EQ(surface_formats[1].colorSpace, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR);
+    vkDestroySurfaceKHR(instance, surface, nullptr);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceSurfaceFormats2KHR) {
+    VkResult res = VK_SUCCESS;
+    VkSurfaceKHR surface{};
+    res = create_surface(instance, surface);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_NE(surface, VK_NULL_HANDLE);
+    uint32_t count = 0;
+    std::array<VkSurfaceFormat2KHR, 2> surface_formats2{};
+    VkPhysicalDeviceSurfaceInfo2KHR surface_info{};
+    surface_info.surface = surface;
+    res = vkGetPhysicalDeviceSurfaceFormats2KHR(physical_device, &surface_info, &count, nullptr);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(count, surface_formats2.size());
+    vkGetPhysicalDeviceSurfaceFormats2KHR(physical_device, &surface_info, &count, surface_formats2.data());
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(surface_formats2[0].pNext, nullptr);
+    ASSERT_EQ(surface_formats2[0].surfaceFormat.format, VK_FORMAT_B8G8R8A8_UNORM);
+    ASSERT_EQ(surface_formats2[0].surfaceFormat.colorSpace, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR);
+    ASSERT_EQ(surface_formats2[1].pNext, nullptr);
+    ASSERT_EQ(surface_formats2[1].surfaceFormat.format, VK_FORMAT_R8G8B8A8_UNORM);
+    ASSERT_EQ(surface_formats2[1].surfaceFormat.colorSpace, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR);
+    vkDestroySurfaceKHR(instance, surface, nullptr);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceSurfaceSupportKHR) {
+    VkResult res = VK_SUCCESS;
+    VkSurfaceKHR surface{};
+    res = create_surface(instance, surface);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_NE(surface, VK_NULL_HANDLE);
+    VkBool32 supported = false;
+    res = vkGetPhysicalDeviceSurfaceSupportKHR(physical_device, 0, surface, &supported);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(supported, true);
+    vkDestroySurfaceKHR(instance, surface, nullptr);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceSurfaceCapabilitiesKHR) {
+    VkResult res = VK_SUCCESS;
+    VkSurfaceKHR surface{};
+    res = create_surface(instance, surface);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_NE(surface, VK_NULL_HANDLE);
+    VkSurfaceCapabilitiesKHR surface_capabilities{};
+    res = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physical_device, surface, &surface_capabilities);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(surface_capabilities.minImageCount, 1);
+    ASSERT_EQ(surface_capabilities.currentExtent.width, std::numeric_limits<uint32_t>::max());
+    ASSERT_EQ(surface_capabilities.currentExtent.height, std::numeric_limits<uint32_t>::max());
+    ASSERT_EQ(surface_capabilities.minImageExtent.width, 1);
+    ASSERT_EQ(surface_capabilities.minImageExtent.height, 1);
+    ASSERT_EQ(surface_capabilities.maxImageArrayLayers, 128);
+    ASSERT_EQ(surface_capabilities.currentTransform, VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR);
+    vkDestroySurfaceKHR(instance, surface, nullptr);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceSurfaceCapabilities2KHR) {
+    VkResult res = VK_SUCCESS;
+    VkSurfaceKHR surface{};
+    res = create_surface(instance, surface);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_NE(surface, VK_NULL_HANDLE);
+    VkSurfaceCapabilities2KHR surface_capabilities2{};
+    VkPhysicalDeviceSurfaceInfo2KHR surface_info{};
+    surface_info.surface = surface;
+    res = vkGetPhysicalDeviceSurfaceCapabilities2KHR(physical_device, &surface_info, &surface_capabilities2);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(surface_capabilities2.surfaceCapabilities.minImageCount, 1);
+    ASSERT_EQ(surface_capabilities2.surfaceCapabilities.currentExtent.width, std::numeric_limits<uint32_t>::max());
+    ASSERT_EQ(surface_capabilities2.surfaceCapabilities.currentExtent.height, std::numeric_limits<uint32_t>::max());
+    ASSERT_EQ(surface_capabilities2.surfaceCapabilities.minImageExtent.width, 1);
+    ASSERT_EQ(surface_capabilities2.surfaceCapabilities.minImageExtent.height, 1);
+    ASSERT_EQ(surface_capabilities2.surfaceCapabilities.maxImageArrayLayers, 128);
+    ASSERT_EQ(surface_capabilities2.surfaceCapabilities.currentTransform, VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR);
+    vkDestroySurfaceKHR(instance, surface, nullptr);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceMemoryProperties) {
+    VkPhysicalDeviceMemoryProperties memory_properties{};
+    vkGetPhysicalDeviceMemoryProperties(physical_device, &memory_properties);
+    ASSERT_EQ(memory_properties.memoryTypeCount, 6);
+    ASSERT_EQ(memory_properties.memoryTypes[0].propertyFlags,
+              VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
+    ASSERT_EQ(memory_properties.memoryTypes[0].heapIndex, 0);
+    ASSERT_EQ(memory_properties.memoryTypes[5].propertyFlags, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+    ASSERT_EQ(memory_properties.memoryTypes[5].heapIndex, 1);
+    ASSERT_EQ(memory_properties.memoryHeapCount, 2);
+    ASSERT_EQ(memory_properties.memoryHeaps[0].flags, VK_MEMORY_HEAP_MULTI_INSTANCE_BIT);
+    ASSERT_EQ(memory_properties.memoryHeaps[0].size, 8000000000);
+    ASSERT_EQ(memory_properties.memoryHeaps[1].flags, VK_MEMORY_HEAP_DEVICE_LOCAL_BIT);
+    ASSERT_EQ(memory_properties.memoryHeaps[1].size, 8000000000);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceMemoryProperties2) {
+    VkPhysicalDeviceMemoryProperties2 memory_properties2{};
+    vkGetPhysicalDeviceMemoryProperties2(physical_device, &memory_properties2);
+    ASSERT_EQ(memory_properties2.memoryProperties.memoryTypeCount, 6);
+    ASSERT_EQ(memory_properties2.memoryProperties.memoryTypes[0].propertyFlags,
+              VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
+    ASSERT_EQ(memory_properties2.memoryProperties.memoryTypes[0].heapIndex, 0);
+    ASSERT_EQ(memory_properties2.memoryProperties.memoryTypes[5].propertyFlags, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+    ASSERT_EQ(memory_properties2.memoryProperties.memoryTypes[5].heapIndex, 1);
+    ASSERT_EQ(memory_properties2.memoryProperties.memoryHeapCount, 2);
+    ASSERT_EQ(memory_properties2.memoryProperties.memoryHeaps[0].flags, VK_MEMORY_HEAP_MULTI_INSTANCE_BIT);
+    ASSERT_EQ(memory_properties2.memoryProperties.memoryHeaps[0].size, 8000000000);
+    ASSERT_EQ(memory_properties2.memoryProperties.memoryHeaps[1].flags, VK_MEMORY_HEAP_DEVICE_LOCAL_BIT);
+    ASSERT_EQ(memory_properties2.memoryProperties.memoryHeaps[1].size, 8000000000);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceFeatures) {
+    VkPhysicalDeviceFeatures features{};
+    vkGetPhysicalDeviceFeatures(physical_device, &features);
+    // Make sure the first and last elements are set to true
+    ASSERT_EQ(features.robustBufferAccess, true);
+    ASSERT_EQ(features.inheritedQueries, true);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceFeatures2) {
+    VkPhysicalDeviceDescriptorIndexingFeaturesEXT descriptor_indexing_features{};
+    descriptor_indexing_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
+
+    VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT blending_operation_advanced_features{};
+    blending_operation_advanced_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
+    blending_operation_advanced_features.pNext = static_cast<void*>(&descriptor_indexing_features);
+
+    VkPhysicalDeviceFeatures2 features2{};
+    features2.pNext = static_cast<void*>(&blending_operation_advanced_features);
+    vkGetPhysicalDeviceFeatures2(physical_device, &features2);
+    // Make sure the first and last elements are set to true
+    ASSERT_EQ(features2.features.robustBufferAccess, true);
+    ASSERT_EQ(features2.features.inheritedQueries, true);
+    ASSERT_EQ(descriptor_indexing_features.shaderInputAttachmentArrayDynamicIndexing, true);
+    ASSERT_EQ(descriptor_indexing_features.runtimeDescriptorArray, true);
+    ASSERT_EQ(blending_operation_advanced_features.advancedBlendCoherentOperations, true);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceFormatProperties) {
+    VkFormatProperties format_properties{};
+    vkGetPhysicalDeviceFormatProperties(physical_device, VK_FORMAT_R8G8B8A8_SRGB, &format_properties);
+    ASSERT_EQ(format_properties.bufferFeatures, 0x00FFFDFF);
+    ASSERT_EQ(format_properties.linearTilingFeatures, 0x00FFFDFF);
+    ASSERT_EQ(format_properties.optimalTilingFeatures, 0x00FFFDFF);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceFormatProperties2) {
+    VkFormatProperties3 format_properties3{};
+    format_properties3.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3;
+    VkFormatProperties2 format_properties2{};
+    format_properties2.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2;
+    format_properties2.pNext = static_cast<void*>(&format_properties3);
+    vkGetPhysicalDeviceFormatProperties2(physical_device, VK_FORMAT_R8G8B8A8_SRGB, &format_properties2);
+    ASSERT_EQ(format_properties2.formatProperties.bufferFeatures, 0x00FFFDFF);
+    ASSERT_EQ(format_properties2.formatProperties.linearTilingFeatures, 0x00FFFDFF);
+    ASSERT_EQ(format_properties2.formatProperties.optimalTilingFeatures, 0x00FFFDFF);
+    ASSERT_EQ(format_properties3.bufferFeatures, 0x00FFFDFF);
+    ASSERT_EQ(format_properties3.linearTilingFeatures, 0x00FFFDFF);
+    ASSERT_EQ(format_properties3.optimalTilingFeatures, 0x400000FFFDFF);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceImageFormatProperties) {
+    VkImageFormatProperties image_format_properties{};
+    vkGetPhysicalDeviceImageFormatProperties(physical_device, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_LINEAR,
+                                             VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, 0, &image_format_properties);
+    ASSERT_EQ(image_format_properties.maxExtent.width, 4096);
+    ASSERT_EQ(image_format_properties.maxExtent.height, 4096);
+    ASSERT_EQ(image_format_properties.maxExtent.depth, 256);
+    ASSERT_EQ(image_format_properties.maxMipLevels, 1);
+    ASSERT_EQ(image_format_properties.maxArrayLayers, 1);
+    ASSERT_EQ(image_format_properties.sampleCounts, VK_SAMPLE_COUNT_1_BIT);
+    ASSERT_EQ(image_format_properties.maxResourceSize, 4294967296 /* this is max of uint32_t + 1*/);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceImageFormatProperties2) {
+    VkImageFormatProperties2 image_format_properties2{};
+    VkPhysicalDeviceImageFormatInfo2 image_format_info2{};
+    image_format_info2.format = VK_FORMAT_R8G8B8A8_SRGB;
+    image_format_info2.type = VK_IMAGE_TYPE_2D;
+    image_format_info2.tiling = VK_IMAGE_TILING_OPTIMAL;
+    image_format_info2.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+    image_format_info2.flags = 0;
+    vkGetPhysicalDeviceImageFormatProperties2(physical_device, &image_format_info2, &image_format_properties2);
+    ASSERT_EQ(image_format_properties2.imageFormatProperties.maxExtent.width, 4096);
+    ASSERT_EQ(image_format_properties2.imageFormatProperties.maxExtent.height, 4096);
+    ASSERT_EQ(image_format_properties2.imageFormatProperties.maxExtent.depth, 256);
+    ASSERT_EQ(image_format_properties2.imageFormatProperties.maxMipLevels, 12);
+    ASSERT_EQ(image_format_properties2.imageFormatProperties.maxArrayLayers, 256);
+    ASSERT_EQ(image_format_properties2.imageFormatProperties.sampleCounts, 0x7F & ~VK_SAMPLE_COUNT_64_BIT);
+    ASSERT_EQ(image_format_properties2.imageFormatProperties.maxResourceSize, 4294967296 /* this is max of uint32_t + 1*/);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceSparseImageFormatProperties) {
+    uint32_t count = 0;
+    VkSparseImageFormatProperties sparse_image_format_properties{};
+    vkGetPhysicalDeviceSparseImageFormatProperties(physical_device, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_TYPE_2D,
+                                                   VK_SAMPLE_COUNT_64_BIT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
+                                                   VK_IMAGE_TILING_OPTIMAL, &count, nullptr);
+    ASSERT_EQ(count, 1);
+    vkGetPhysicalDeviceSparseImageFormatProperties(physical_device, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_TYPE_2D,
+                                                   VK_SAMPLE_COUNT_64_BIT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
+                                                   VK_IMAGE_TILING_OPTIMAL, &count, &sparse_image_format_properties);
+    ASSERT_EQ(sparse_image_format_properties.aspectMask, VK_IMAGE_ASPECT_COLOR_BIT);
+    ASSERT_EQ(sparse_image_format_properties.imageGranularity.width, 4);
+    ASSERT_EQ(sparse_image_format_properties.imageGranularity.height, 4);
+    ASSERT_EQ(sparse_image_format_properties.imageGranularity.depth, 4);
+    ASSERT_EQ(sparse_image_format_properties.flags, VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceSparseImageFormatProperties2) {
+    uint32_t count = 0;
+    VkSparseImageFormatProperties2 sparse_image_format_properties2{};
+    VkPhysicalDeviceSparseImageFormatInfo2 sparse_image_format_info2{};
+    sparse_image_format_info2.format = VK_FORMAT_R8G8B8A8_SRGB;
+    sparse_image_format_info2.type = VK_IMAGE_TYPE_2D;
+    sparse_image_format_info2.samples = VK_SAMPLE_COUNT_64_BIT;
+    sparse_image_format_info2.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+    sparse_image_format_info2.tiling = VK_IMAGE_TILING_OPTIMAL;
+    vkGetPhysicalDeviceSparseImageFormatProperties2(physical_device, &sparse_image_format_info2, &count, nullptr);
+    ASSERT_EQ(count, 1);
+    vkGetPhysicalDeviceSparseImageFormatProperties2(physical_device, &sparse_image_format_info2, &count,
+                                                    &sparse_image_format_properties2);
+    ASSERT_EQ(sparse_image_format_properties2.properties.aspectMask, VK_IMAGE_ASPECT_COLOR_BIT);
+    ASSERT_EQ(sparse_image_format_properties2.properties.imageGranularity.width, 4);
+    ASSERT_EQ(sparse_image_format_properties2.properties.imageGranularity.height, 4);
+    ASSERT_EQ(sparse_image_format_properties2.properties.imageGranularity.depth, 4);
+    ASSERT_EQ(sparse_image_format_properties2.properties.flags, VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceProperties) {
+    VkPhysicalDeviceProperties physical_device_properties{};
+    vkGetPhysicalDeviceProperties(physical_device, &physical_device_properties);
+    ASSERT_EQ(physical_device_properties.apiVersion, VK_HEADER_VERSION_COMPLETE);
+    ASSERT_EQ(physical_device_properties.driverVersion, 1);
+    ASSERT_EQ(physical_device_properties.vendorID, 0xba5eba11);
+    ASSERT_EQ(physical_device_properties.deviceID, 0xf005ba11);
+    ASSERT_EQ(physical_device_properties.deviceType, VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU);
+    ASSERT_STREQ(&physical_device_properties.deviceName[0], "Vulkan Mock Device");
+    ASSERT_EQ(physical_device_properties.pipelineCacheUUID[0], 18);
+    ASSERT_EQ(physical_device_properties.limits.maxImageDimension1D, 4096);
+    ASSERT_EQ(physical_device_properties.limits.nonCoherentAtomSize, 256);
+    ASSERT_EQ(physical_device_properties.sparseProperties.residencyAlignedMipSize, VK_TRUE);
+    ASSERT_EQ(physical_device_properties.sparseProperties.residencyNonResidentStrict, VK_TRUE);
+    ASSERT_EQ(physical_device_properties.sparseProperties.residencyStandard2DBlockShape, VK_TRUE);
+    ASSERT_EQ(physical_device_properties.sparseProperties.residencyStandard2DMultisampleBlockShape, VK_TRUE);
+    ASSERT_EQ(physical_device_properties.sparseProperties.residencyStandard3DBlockShape, VK_TRUE);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceProperties2) {
+    VkPhysicalDeviceVulkan11Properties properties11{};
+    properties11.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
+
+    VkPhysicalDeviceVulkan12Properties properties12{};
+    properties12.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
+    properties12.pNext = static_cast<void*>(&properties11);
+
+    VkPhysicalDeviceVulkan13Properties properties13{};
+    properties13.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES;
+    properties13.pNext = static_cast<void*>(&properties12);
+
+    VkPhysicalDeviceProtectedMemoryProperties protected_memory_properties{};
+    protected_memory_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES;
+    protected_memory_properties.pNext = static_cast<void*>(&properties13);
+
+    VkPhysicalDeviceFloatControlsProperties float_controls_properties{};
+    float_controls_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
+    float_controls_properties.pNext = static_cast<void*>(&protected_memory_properties);
+
+    VkPhysicalDeviceConservativeRasterizationPropertiesEXT conservative_rasterization_properties{};
+    conservative_rasterization_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT;
+    conservative_rasterization_properties.pNext = static_cast<void*>(&float_controls_properties);
+
+    VkPhysicalDeviceRayTracingPipelinePropertiesKHR raytracing_pipeline_properties{};
+    raytracing_pipeline_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
+    raytracing_pipeline_properties.pNext = static_cast<void*>(&conservative_rasterization_properties);
+
+    VkPhysicalDeviceRayTracingPropertiesNV ray_tracing_properties{};
+    ray_tracing_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV;
+    ray_tracing_properties.pNext = static_cast<void*>(&raytracing_pipeline_properties);
+
+    VkPhysicalDeviceTexelBufferAlignmentProperties texel_buffer_alignment_properties{};
+    texel_buffer_alignment_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
+    texel_buffer_alignment_properties.pNext = static_cast<void*>(&ray_tracing_properties);
+
+    VkPhysicalDeviceDescriptorBufferPropertiesEXT descriptor_buffer_properties{};
+    descriptor_buffer_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT;
+    descriptor_buffer_properties.pNext = static_cast<void*>(&texel_buffer_alignment_properties);
+
+    VkPhysicalDeviceMeshShaderPropertiesEXT mesh_shader_properties{};
+    mesh_shader_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT;
+    mesh_shader_properties.pNext = static_cast<void*>(&descriptor_buffer_properties);
+
+    VkPhysicalDeviceFragmentDensityMap2PropertiesEXT fragment_density_map2_properties{};
+    fragment_density_map2_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT;
+    fragment_density_map2_properties.pNext = static_cast<void*>(&mesh_shader_properties);
+
+    VkPhysicalDeviceDriverProperties driver_properties{};
+    driver_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
+    driver_properties.pNext = static_cast<void*>(&fragment_density_map2_properties);
+
+    VkPhysicalDeviceProperties2 properties2{};
+    properties2.pNext = static_cast<void*>(&driver_properties);
+    vkGetPhysicalDeviceProperties2(physical_device, &properties2);
+    ASSERT_EQ(properties2.properties.apiVersion, VK_HEADER_VERSION_COMPLETE);
+    ASSERT_EQ(properties2.properties.driverVersion, 1);
+    ASSERT_EQ(properties2.properties.vendorID, 0xba5eba11);
+    ASSERT_EQ(properties2.properties.deviceID, 0xf005ba11);
+    ASSERT_EQ(properties2.properties.deviceType, VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU);
+    ASSERT_STREQ(&properties2.properties.deviceName[0], "Vulkan Mock Device");
+    ASSERT_EQ(properties2.properties.pipelineCacheUUID[0], 18);
+    ASSERT_EQ(properties2.properties.limits.maxImageDimension1D, 4096);
+    ASSERT_EQ(properties2.properties.limits.nonCoherentAtomSize, 256);
+    ASSERT_EQ(properties2.properties.sparseProperties.residencyAlignedMipSize, VK_TRUE);
+    ASSERT_EQ(properties2.properties.sparseProperties.residencyNonResidentStrict, VK_TRUE);
+    ASSERT_EQ(properties2.properties.sparseProperties.residencyStandard2DBlockShape, VK_TRUE);
+    ASSERT_EQ(properties2.properties.sparseProperties.residencyStandard2DMultisampleBlockShape, VK_TRUE);
+    ASSERT_EQ(properties2.properties.sparseProperties.residencyStandard3DBlockShape, VK_TRUE);
+
+    ASSERT_EQ(properties11.protectedNoFault, VK_FALSE);
+    ASSERT_EQ(properties12.denormBehaviorIndependence, VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL);
+    ASSERT_EQ(properties12.roundingModeIndependence, VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL);
+    ASSERT_EQ(properties13.storageTexelBufferOffsetSingleTexelAlignment, VK_TRUE);
+    ASSERT_EQ(properties13.uniformTexelBufferOffsetSingleTexelAlignment, VK_TRUE);
+    ASSERT_EQ(properties13.storageTexelBufferOffsetAlignmentBytes, 16);
+    ASSERT_EQ(properties13.uniformTexelBufferOffsetAlignmentBytes, 16);
+    ASSERT_EQ(protected_memory_properties.protectedNoFault, VK_FALSE);
+    ASSERT_EQ(float_controls_properties.denormBehaviorIndependence, VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL);
+    ASSERT_EQ(float_controls_properties.roundingModeIndependence, VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL);
+    ASSERT_EQ(conservative_rasterization_properties.primitiveOverestimationSize, 0.00195313f);
+    ASSERT_EQ(conservative_rasterization_properties.conservativePointAndLineRasterization, VK_TRUE);
+    ASSERT_EQ(conservative_rasterization_properties.degenerateTrianglesRasterized, VK_TRUE);
+    ASSERT_EQ(conservative_rasterization_properties.degenerateLinesRasterized, VK_TRUE);
+    ASSERT_EQ(raytracing_pipeline_properties.shaderGroupHandleSize, 32);
+    ASSERT_EQ(raytracing_pipeline_properties.shaderGroupBaseAlignment, 64);
+    ASSERT_EQ(raytracing_pipeline_properties.shaderGroupHandleCaptureReplaySize, 32);
+    ASSERT_EQ(ray_tracing_properties.shaderGroupHandleSize, 32);
+    ASSERT_EQ(ray_tracing_properties.shaderGroupBaseAlignment, 64);
+    ASSERT_EQ(texel_buffer_alignment_properties.storageTexelBufferOffsetSingleTexelAlignment, VK_TRUE);
+    ASSERT_EQ(texel_buffer_alignment_properties.uniformTexelBufferOffsetSingleTexelAlignment, VK_TRUE);
+    ASSERT_EQ(texel_buffer_alignment_properties.storageTexelBufferOffsetAlignmentBytes, 16);
+    ASSERT_EQ(texel_buffer_alignment_properties.uniformTexelBufferOffsetAlignmentBytes, 16);
+    ASSERT_EQ(descriptor_buffer_properties.combinedImageSamplerDescriptorSingleArray, VK_TRUE);
+    ASSERT_EQ(descriptor_buffer_properties.bufferlessPushDescriptors, VK_TRUE);
+    ASSERT_EQ(descriptor_buffer_properties.allowSamplerImageViewPostSubmitCreation, VK_TRUE);
+    ASSERT_EQ(descriptor_buffer_properties.descriptorBufferOffsetAlignment, 4);
+    ASSERT_EQ(mesh_shader_properties.meshOutputPerVertexGranularity, 32);
+    ASSERT_EQ(mesh_shader_properties.meshOutputPerPrimitiveGranularity, 32);
+    ASSERT_EQ(mesh_shader_properties.prefersLocalInvocationVertexOutput, VK_TRUE);
+    ASSERT_EQ(mesh_shader_properties.prefersLocalInvocationPrimitiveOutput, VK_TRUE);
+    ASSERT_EQ(mesh_shader_properties.prefersCompactVertexOutput, VK_TRUE);
+    ASSERT_EQ(mesh_shader_properties.prefersCompactPrimitiveOutput, VK_TRUE);
+    ASSERT_EQ(fragment_density_map2_properties.subsampledLoads, VK_FALSE);
+    ASSERT_EQ(fragment_density_map2_properties.subsampledCoarseReconstructionEarlyAccess, VK_FALSE);
+    ASSERT_EQ(fragment_density_map2_properties.maxSubsampledArrayLayers, 2);
+    ASSERT_EQ(fragment_density_map2_properties.maxDescriptorSetSubsampledSamplers, 1);
+    ASSERT_EQ(std::string(driver_properties.driverName), "Vulkan Mock Device");
+    ASSERT_EQ(std::string(driver_properties.driverInfo), "Branch: " GIT_BRANCH_NAME " Tag Info: " GIT_TAG_INFO);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceExternalSemaphoreProperties) {
+    VkPhysicalDeviceExternalSemaphoreInfo external_semaphore_info{};
+    VkExternalSemaphoreProperties external_semaphore_properties{};
+    vkGetPhysicalDeviceExternalSemaphoreProperties(physical_device, &external_semaphore_info, &external_semaphore_properties);
+    ASSERT_EQ(external_semaphore_properties.exportFromImportedHandleTypes, 0x1F);
+    ASSERT_EQ(external_semaphore_properties.compatibleHandleTypes, 0x1F);
+    ASSERT_EQ(external_semaphore_properties.externalSemaphoreFeatures, 0x3);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceExternalFenceProperties) {
+    VkPhysicalDeviceExternalFenceInfo external_fence_info{};
+    VkExternalFenceProperties external_fence_properties{};
+    vkGetPhysicalDeviceExternalFenceProperties(physical_device, &external_fence_info, &external_fence_properties);
+    ASSERT_EQ(external_fence_properties.exportFromImportedHandleTypes, 0xF);
+    ASSERT_EQ(external_fence_properties.compatibleHandleTypes, 0xF);
+    ASSERT_EQ(external_fence_properties.externalFenceFeatures, 0x3);
+}
+TEST_F(MockICD, vkGetPhysicalDeviceExternalBufferProperties) {
+    VkPhysicalDeviceExternalBufferInfo external_buffer_info{};
+    external_buffer_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
+    VkExternalBufferProperties external_buffer_properties{};
+    vkGetPhysicalDeviceExternalBufferProperties(physical_device, &external_buffer_info, &external_buffer_properties);
+    ASSERT_EQ(external_buffer_properties.externalMemoryProperties.externalMemoryFeatures, 0x7);
+    ASSERT_EQ(external_buffer_properties.externalMemoryProperties.exportFromImportedHandleTypes, 0x1FF);
+    ASSERT_EQ(external_buffer_properties.externalMemoryProperties.compatibleHandleTypes, 0x1FF);
+
+    external_buffer_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX;
+    vkGetPhysicalDeviceExternalBufferProperties(physical_device, &external_buffer_info, &external_buffer_properties);
+    ASSERT_EQ(external_buffer_properties.externalMemoryProperties.externalMemoryFeatures, 0);
+    ASSERT_EQ(external_buffer_properties.externalMemoryProperties.exportFromImportedHandleTypes, 0);
+    ASSERT_EQ(external_buffer_properties.externalMemoryProperties.compatibleHandleTypes,
+              VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX);
+}
+
+/*
+ * Exercises the following commands:
+ * vkCreateBuffer
+ * vkGetBufferMemoryRequirements
+ * vkGetBufferMemoryRequirements2
+ * vkGetDeviceBufferMemoryRequirements
+ * vkAllocateMemory
+ * vkMapMemory
+ * vkUnmapMemory
+ * vkGetBufferDeviceAddress
+ * vkGetBufferDeviceAddressKHR
+ * vkGetBufferDeviceAddressEXT
+ * vkDestroyBuffer
+ * vkFreeMemory
+ */
+TEST_F(MockICD, BufferOperations) {
+    VkResult res = VK_SUCCESS;
+
+    VkBufferCreateInfo buffer_create_info{};
+    buffer_create_info.size = 128;
+    VkBuffer buffer{};
+    res = vkCreateBuffer(device, &buffer_create_info, nullptr, &buffer);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_NE(buffer, VK_NULL_HANDLE);
+
+    VkMemoryRequirements memory_requirements{};
+    vkGetBufferMemoryRequirements(device, buffer, &memory_requirements);
+    ASSERT_EQ(memory_requirements.size, 4096);
+    ASSERT_EQ(memory_requirements.alignment, 1);
+    ASSERT_EQ(memory_requirements.memoryTypeBits, 0xFFFF);
+
+    VkBufferMemoryRequirementsInfo2 memory_requirements_info2{};
+    VkMemoryRequirements2 memory_requirements2{};
+    vkGetBufferMemoryRequirements2(device, &memory_requirements_info2, &memory_requirements2);
+    ASSERT_EQ(memory_requirements2.memoryRequirements.size, 4096);
+    ASSERT_EQ(memory_requirements2.memoryRequirements.alignment, 1);
+    ASSERT_EQ(memory_requirements2.memoryRequirements.memoryTypeBits, 0xFFFF);
+
+    VkDeviceBufferMemoryRequirements buffer_memory_requirements{};
+    buffer_memory_requirements.pCreateInfo = &buffer_create_info;
+    vkGetDeviceBufferMemoryRequirements(device, &buffer_memory_requirements, &memory_requirements2);
+    ASSERT_EQ(memory_requirements2.memoryRequirements.size, 4096);
+    ASSERT_EQ(memory_requirements2.memoryRequirements.alignment, 1);
+    ASSERT_EQ(memory_requirements2.memoryRequirements.memoryTypeBits, 0xFFFF);
+
+    VkMemoryAllocateInfo allocate_info{};
+    allocate_info.allocationSize = memory_requirements.size;
+    VkDeviceMemory memory{};
+    res = vkAllocateMemory(device, &allocate_info, nullptr, &memory);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_NE(memory, VK_NULL_HANDLE);
+
+    std::array<uint32_t, 32> source_data;
+    void* data = nullptr;
+    res = vkMapMemory(device, memory, 0, memory_requirements.size, 0, &data);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_NE(data, nullptr);
+    memcpy(data, source_data.data(), source_data.size());
+    vkUnmapMemory(device, memory);
+
+    VkBufferDeviceAddressInfo buffer_device_address_info{};
+    buffer_device_address_info.buffer = buffer;
+    VkDeviceAddress device_address = vkGetBufferDeviceAddress(device, &buffer_device_address_info);
+    ASSERT_NE(device_address, 0);
+
+    auto vkGetBufferDeviceAddressEXT =
+        reinterpret_cast<PFN_vkGetBufferDeviceAddressEXT>(vkGetDeviceProcAddr(device, "vkGetBufferDeviceAddressEXT"));
+    ASSERT_NE(vkGetBufferDeviceAddressEXT, nullptr);
+    device_address = vkGetBufferDeviceAddressEXT(device, &buffer_device_address_info);
+    ASSERT_NE(device_address, 0);
+
+    auto vkGetBufferDeviceAddressKHR =
+        reinterpret_cast<PFN_vkGetBufferDeviceAddressKHR>(vkGetDeviceProcAddr(device, "vkGetBufferDeviceAddressKHR"));
+    ASSERT_NE(vkGetBufferDeviceAddressKHR, nullptr);
+    device_address = vkGetBufferDeviceAddressKHR(device, &buffer_device_address_info);
+    ASSERT_NE(device_address, 0);
+
+    vkDestroyBuffer(device, buffer, nullptr);
+    vkFreeMemory(device, memory, nullptr);
+}
+
+/*
+ * Exercises the following commands:
+ * vkCreateImage
+ * vkGetImageSubresourceLayout
+ * vkGetImageMemoryRequirements
+ * vkGetImageMemoryRequirements2
+ * vkGetDeviceImageMemoryRequirements
+ * vkGetImageSparseMemoryRequirements
+ * vkGetImageSparseMemoryRequirements2
+ * vkAllocateMemory
+ * vkMapMemory2KHR
+ * vkUnmapMemory2KHR
+ * vkDestroyImage
+ * vkFreeMemory
+ */
+TEST_F(MockICD, ImageOperations) {
+    VkResult res = VK_SUCCESS;
+
+    VkImageCreateInfo image_create_info{};
+    image_create_info.imageType = VK_IMAGE_TYPE_2D;
+    image_create_info.format = VK_FORMAT_R8G8B8A8_SRGB;
+    image_create_info.extent = {8, 8, 8};
+    image_create_info.mipLevels = 1;
+    image_create_info.arrayLayers = 1;
+    image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
+    image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
+    image_create_info.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+    image_create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+    image_create_info.queueFamilyIndexCount = 0;
+    image_create_info.pQueueFamilyIndices = nullptr;
+    image_create_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+    VkImage image{};
+    res = vkCreateImage(device, &image_create_info, nullptr, &image);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_NE(image, VK_NULL_HANDLE);
+
+    VkImageSubresource image_subresource{};
+    VkSubresourceLayout subresource_layout{};
+    vkGetImageSubresourceLayout(device, image, &image_subresource, &subresource_layout);
+    ASSERT_EQ(subresource_layout.arrayPitch, 0);
+    ASSERT_EQ(subresource_layout.depthPitch, 0);
+    ASSERT_EQ(subresource_layout.offset, 0);
+    ASSERT_EQ(subresource_layout.rowPitch, 0);
+    ASSERT_EQ(subresource_layout.size, 0);
+
+    VkMemoryRequirements memory_requirements{};
+    vkGetImageMemoryRequirements(device, image, &memory_requirements);
+    ASSERT_EQ(memory_requirements.size, 8 * 8 * 8 * 32 /*refer to GetImageSizeFromCreateInfo for size calc*/);
+    ASSERT_EQ(memory_requirements.alignment, 1);
+    ASSERT_EQ(memory_requirements.memoryTypeBits, 0xFFFF & ~(0x1 << 3));
+
+    VkImageMemoryRequirementsInfo2 memory_requirements_info2{};
+    VkMemoryRequirements2 memory_requirements2{};
+    vkGetImageMemoryRequirements2(device, &memory_requirements_info2, &memory_requirements2);
+    ASSERT_EQ(memory_requirements2.memoryRequirements.size, 0);
+    ASSERT_EQ(memory_requirements2.memoryRequirements.alignment, 1);
+    ASSERT_EQ(memory_requirements2.memoryRequirements.memoryTypeBits, 0xFFFF & ~(0x1 << 3));
+
+    VkDeviceImageMemoryRequirements image_memory_requirements{};
+    image_memory_requirements.pCreateInfo = &image_create_info;
+    vkGetDeviceImageMemoryRequirements(device, &image_memory_requirements, &memory_requirements2);
+    ASSERT_EQ(memory_requirements2.memoryRequirements.size, 8 * 8 * 8 * 32 /*refer to GetImageSizeFromCreateInfo for size calc*/);
+    ASSERT_EQ(memory_requirements2.memoryRequirements.alignment, 1);
+    ASSERT_EQ(memory_requirements2.memoryRequirements.memoryTypeBits, 0xFFFF & ~(0x1 << 3));
+
+    uint32_t count = 0;
+    vkGetImageSparseMemoryRequirements(device, image, &count, nullptr);
+    ASSERT_EQ(count, 1);
+    VkSparseImageMemoryRequirements sparse_image_memory_requirements{};
+    vkGetImageSparseMemoryRequirements(device, image, &count, &sparse_image_memory_requirements);
+    ASSERT_EQ(count, 1);
+    ASSERT_EQ(sparse_image_memory_requirements.imageMipTailFirstLod, 0);
+    ASSERT_EQ(sparse_image_memory_requirements.imageMipTailSize, 8);
+    ASSERT_EQ(sparse_image_memory_requirements.imageMipTailOffset, 0);
+    ASSERT_EQ(sparse_image_memory_requirements.imageMipTailStride, 4);
+    ASSERT_EQ(sparse_image_memory_requirements.formatProperties.imageGranularity.width, 4);
+    ASSERT_EQ(sparse_image_memory_requirements.formatProperties.imageGranularity.height, 4);
+    ASSERT_EQ(sparse_image_memory_requirements.formatProperties.imageGranularity.depth, 4);
+    ASSERT_EQ(sparse_image_memory_requirements.formatProperties.flags, VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT);
+    ASSERT_EQ(sparse_image_memory_requirements.formatProperties.aspectMask, 1 | 2 | 4 | 8);
+
+    count = 0;
+    VkImageSparseMemoryRequirementsInfo2 sparse_memory_requirement_info2{};
+    sparse_memory_requirement_info2.image = image;
+    vkGetImageSparseMemoryRequirements2(device, &sparse_memory_requirement_info2, &count, nullptr);
+    ASSERT_EQ(count, 1);
+    VkSparseImageMemoryRequirements2 sparse_image_memory_reqs2{};
+    vkGetImageSparseMemoryRequirements2(device, &sparse_memory_requirement_info2, &count, &sparse_image_memory_reqs2);
+    ASSERT_EQ(sparse_image_memory_reqs2.memoryRequirements.imageMipTailFirstLod, 0);
+    ASSERT_EQ(sparse_image_memory_reqs2.memoryRequirements.imageMipTailSize, 8);
+    ASSERT_EQ(sparse_image_memory_reqs2.memoryRequirements.imageMipTailOffset, 0);
+    ASSERT_EQ(sparse_image_memory_reqs2.memoryRequirements.imageMipTailStride, 4);
+    ASSERT_EQ(sparse_image_memory_reqs2.memoryRequirements.formatProperties.imageGranularity.width, 4);
+    ASSERT_EQ(sparse_image_memory_reqs2.memoryRequirements.formatProperties.imageGranularity.height, 4);
+    ASSERT_EQ(sparse_image_memory_reqs2.memoryRequirements.formatProperties.imageGranularity.depth, 4);
+    ASSERT_EQ(sparse_image_memory_reqs2.memoryRequirements.formatProperties.flags, VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT);
+    ASSERT_EQ(sparse_image_memory_reqs2.memoryRequirements.formatProperties.aspectMask, 1 | 2 | 4 | 8);
+
+    VkMemoryAllocateInfo allocate_info{};
+    allocate_info.allocationSize = memory_requirements.size;
+    VkDeviceMemory memory{};
+    res = vkAllocateMemory(device, &allocate_info, nullptr, &memory);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_NE(memory, VK_NULL_HANDLE);
+
+    auto vkMapMemory2KHR = reinterpret_cast<PFN_vkMapMemory2KHR>(vkGetDeviceProcAddr(device, "vkMapMemory2KHR"));
+    auto vkUnmapMemory2KHR = reinterpret_cast<PFN_vkUnmapMemory2KHR>(vkGetDeviceProcAddr(device, "vkUnmapMemory2KHR"));
+    ASSERT_NE(vkMapMemory2KHR, nullptr);
+    ASSERT_NE(vkUnmapMemory2KHR, nullptr);
+
+    std::array<uint32_t, 32> source_data;
+    void* data = nullptr;
+    VkMemoryMapInfoKHR memory_map_info{};
+    memory_map_info.memory = memory;
+    memory_map_info.size = memory_requirements.size;
+    res = vkMapMemory2KHR(device, &memory_map_info, &data);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_NE(data, nullptr);
+    memcpy(data, source_data.data(), source_data.size());
+    VkMemoryUnmapInfoKHR memory_unmap_info{};
+    memory_unmap_info.memory = memory;
+    vkUnmapMemory2KHR(device, &memory_unmap_info);
+
+    vkDestroyImage(device, image, nullptr);
+    vkFreeMemory(device, memory, nullptr);
+}
+
+/*
+ * Exercises the following commands:
+ * vkCreateSwapchainKHR
+ * vkGetSwapchainImagesKHR
+ * vkDestroySwapchainKHR
+ * vkAcquireNextImageKHR
+ * vkAcquireNextImage2KHR
+ */
+TEST_F(MockICD, SwapchainLifeCycle) {
+    VkResult res = VK_SUCCESS;
+    VkSurfaceKHR surface{};
+    res = create_surface(instance, surface);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_NE(surface, VK_NULL_HANDLE);
+
+    VkSwapchainCreateInfoKHR swapchain_create_info{};
+    swapchain_create_info.surface = surface;
+    swapchain_create_info.minImageCount = 1;
+    VkSwapchainKHR swapchain{};
+    res = vkCreateSwapchainKHR(device, &swapchain_create_info, nullptr, &swapchain);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_NE(swapchain, VK_NULL_HANDLE);
+
+    uint32_t count = 0;
+    res = vkGetSwapchainImagesKHR(device, swapchain, &count, nullptr);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(count, 1);
+    std::array<VkImage, 1> swapchain_images;
+    res = vkGetSwapchainImagesKHR(device, swapchain, &count, swapchain_images.data());
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_NE(swapchain_images[0], VK_NULL_HANDLE);
+
+    uint32_t image_index = 10;  // arbitrary non zero value
+    res = vkAcquireNextImageKHR(device, swapchain, 0, VK_NULL_HANDLE, VK_NULL_HANDLE, &image_index);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(image_index, 0);
+
+    VkAcquireNextImageInfoKHR acquire_info{};
+    acquire_info.swapchain = swapchain;
+    res = vkAcquireNextImage2KHR(device, &acquire_info, &image_index);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(image_index, 0);
+
+    vkDestroySwapchainKHR(device, swapchain, nullptr);
+    vkDestroySurfaceKHR(instance, surface, nullptr);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceMultisamplePropertiesEXT) {
+    auto vkGetPhysicalDeviceMultisamplePropertiesEXT = reinterpret_cast<PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT>(
+        vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT"));
+    ASSERT_NE(vkGetPhysicalDeviceMultisamplePropertiesEXT, nullptr);
+    VkMultisamplePropertiesEXT multisample_properties{};
+    vkGetPhysicalDeviceMultisamplePropertiesEXT(physical_device, VK_SAMPLE_COUNT_16_BIT, &multisample_properties);
+    ASSERT_EQ(multisample_properties.maxSampleLocationGridSize.width, 32);
+    ASSERT_EQ(multisample_properties.maxSampleLocationGridSize.height, 32);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceFragmentShadingRatesKHR) {
+    auto vkGetPhysicalDeviceFragmentShadingRatesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR>(
+        vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR"));
+    ASSERT_NE(vkGetPhysicalDeviceFragmentShadingRatesKHR, nullptr);
+
+    VkResult res = VK_SUCCESS;
+    uint32_t count = 0;
+    res = vkGetPhysicalDeviceFragmentShadingRatesKHR(physical_device, &count, nullptr);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(count, 1);
+
+    VkPhysicalDeviceFragmentShadingRateKHR fragment_shading_rates{};
+    res = vkGetPhysicalDeviceFragmentShadingRatesKHR(physical_device, &count, &fragment_shading_rates);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(count, 1);
+    ASSERT_EQ(fragment_shading_rates.sampleCounts, VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT);
+    ASSERT_EQ(fragment_shading_rates.fragmentSize.width, 8);
+    ASSERT_EQ(fragment_shading_rates.fragmentSize.height, 8);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceCalibrateableTimeDomainsEXT) {
+    auto vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = reinterpret_cast<PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT>(
+        vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT"));
+    ASSERT_NE(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, nullptr);
+
+    VkResult res = VK_SUCCESS;
+    uint32_t count = 0;
+    res = vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physical_device, &count, nullptr);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(count, 1);
+
+    VkTimeDomainEXT time_domain{};
+    res = vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physical_device, &count, &time_domain);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(count, 1);
+    ASSERT_EQ(time_domain, VK_TIME_DOMAIN_DEVICE_EXT);
+}
+
+#if defined(WIN32)
+TEST_F(MockICD, vkGetFenceWin32HandleKHR) {
+    auto vkGetFenceWin32HandleKHR =
+        reinterpret_cast<PFN_vkGetFenceWin32HandleKHR>(vkGetDeviceProcAddr(device, "vkGetFenceWin32HandleKHR"));
+    ASSERT_NE(vkGetFenceWin32HandleKHR, nullptr);
+    VkFenceGetWin32HandleInfoKHR get_win32_handle_info{};
+    HANDLE handle{};
+    VkResult res = vkGetFenceWin32HandleKHR(device, &get_win32_handle_info, &handle);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(handle, (HANDLE)0x12345678);
+}
+#endif  // defined(WIN32)
+
+TEST_F(MockICD, vkGetFenceFdKHR) {
+    auto vkGetFenceFdKHR = reinterpret_cast<PFN_vkGetFenceFdKHR>(vkGetDeviceProcAddr(device, "vkGetFenceFdKHR"));
+    ASSERT_NE(vkGetFenceFdKHR, nullptr);
+    VkFenceGetFdInfoKHR get_win32_handle_info{};
+    int handle{};
+    VkResult res = vkGetFenceFdKHR(device, &get_win32_handle_info, &handle);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(handle, 0x42);
+}
+
+TEST_F(MockICD, vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR) {
+    auto vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR =
+        reinterpret_cast<PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR>(
+            vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR"));
+    ASSERT_NE(vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, nullptr);
+
+    VkResult res = VK_SUCCESS;
+    uint32_t count = 0;
+    res = vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physical_device, 0, &count, nullptr, nullptr);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(count, 3);
+
+    std::array<VkPerformanceCounterKHR, 3> counters{};
+    std::array<VkPerformanceCounterDescriptionKHR, 3> counter_descriptions{};
+    res = vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physical_device, 0, &count, counters.data(),
+                                                                          counter_descriptions.data());
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(count, 3);
+    ASSERT_EQ(counters[0].unit, VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR);
+    ASSERT_EQ(counters[0].scope, VK_QUERY_SCOPE_COMMAND_BUFFER_KHR);
+    ASSERT_EQ(counters[0].storage, VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR);
+    ASSERT_EQ(counters[0].uuid[0], 0x01);
+    ASSERT_EQ(counters[1].unit, VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR);
+    ASSERT_EQ(counters[1].scope, VK_QUERY_SCOPE_RENDER_PASS_KHR);
+    ASSERT_EQ(counters[1].storage, VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR);
+    ASSERT_EQ(counters[1].uuid[0], 0x02);
+    ASSERT_EQ(counters[2].unit, VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR);
+    ASSERT_EQ(counters[2].scope, VK_QUERY_SCOPE_COMMAND_KHR);
+    ASSERT_EQ(counters[2].storage, VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR);
+    ASSERT_EQ(counters[2].uuid[0], 0x03);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR) {
+    auto vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR =
+        reinterpret_cast<PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR>(
+            vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR"));
+    ASSERT_NE(vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, nullptr);
+    VkQueryPoolPerformanceCreateInfoKHR performance_query_create_info{};
+    uint32_t num_passes = 0;
+    vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physical_device, &performance_query_create_info, &num_passes);
+    ASSERT_EQ(num_passes, 1);
+}
+
+TEST_F(MockICD, vkGetShaderModuleIdentifierEXT) {
+    auto vkGetShaderModuleIdentifierEXT =
+        reinterpret_cast<PFN_vkGetShaderModuleIdentifierEXT>(vkGetDeviceProcAddr(device, "vkGetShaderModuleIdentifierEXT"));
+    ASSERT_NE(vkGetShaderModuleIdentifierEXT, nullptr);
+    VkShaderModule shader_module{};
+    VkShaderModuleIdentifierEXT identifier{};
+    vkGetShaderModuleIdentifierEXT(device, shader_module, &identifier);
+    ASSERT_EQ(identifier.identifierSize, 1);
+    ASSERT_EQ(identifier.identifier[0], 0x01);
+}
+
+TEST_F(MockICD, vkGetDescriptorSetLayoutSizeEXT) {
+    auto vkGetDescriptorSetLayoutSizeEXT =
+        reinterpret_cast<PFN_vkGetDescriptorSetLayoutSizeEXT>(vkGetDeviceProcAddr(device, "vkGetDescriptorSetLayoutSizeEXT"));
+    ASSERT_NE(vkGetDescriptorSetLayoutSizeEXT, nullptr);
+
+    VkDescriptorSetLayout layout{};
+    VkDeviceSize layout_size_in_bytes = 0;
+    vkGetDescriptorSetLayoutSizeEXT(device, layout, &layout_size_in_bytes);
+    ASSERT_EQ(layout_size_in_bytes, 4);
+}
+
+TEST_F(MockICD, vkGetAccelerationStructureBuildSizesKHR) {
+    auto vkGetAccelerationStructureBuildSizesKHR = reinterpret_cast<PFN_vkGetAccelerationStructureBuildSizesKHR>(
+        vkGetDeviceProcAddr(device, "vkGetAccelerationStructureBuildSizesKHR"));
+    ASSERT_NE(vkGetAccelerationStructureBuildSizesKHR, nullptr);
+
+    VkAccelerationStructureBuildGeometryInfoKHR build_info{};
+    uint32_t max_primitive_count = 0;
+    VkAccelerationStructureBuildSizesInfoKHR size_info{};
+    vkGetAccelerationStructureBuildSizesKHR(device, VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR, &build_info,
+                                            &max_primitive_count, &size_info);
+    ASSERT_EQ(size_info.accelerationStructureSize, 4);
+    ASSERT_EQ(size_info.updateScratchSize, 4);
+    ASSERT_EQ(size_info.buildScratchSize, 4);
+}
+
+TEST_F(MockICD, vkGetAccelerationStructureMemoryRequirementsNV) {
+    auto vkGetAccelerationStructureMemoryRequirementsNV = reinterpret_cast<PFN_vkGetAccelerationStructureMemoryRequirementsNV>(
+        vkGetDeviceProcAddr(device, "vkGetAccelerationStructureMemoryRequirementsNV"));
+    ASSERT_NE(vkGetAccelerationStructureMemoryRequirementsNV, nullptr);
+
+    VkAccelerationStructureMemoryRequirementsInfoNV acceleration_structure_memory_requirements_info{};
+    VkMemoryRequirements2KHR memory_requirements{};
+    vkGetAccelerationStructureMemoryRequirementsNV(device, &acceleration_structure_memory_requirements_info, &memory_requirements);
+    ASSERT_EQ(memory_requirements.memoryRequirements.size, 4096);
+    ASSERT_EQ(memory_requirements.memoryRequirements.alignment, 1);
+    ASSERT_EQ(memory_requirements.memoryRequirements.memoryTypeBits, 0xFFFF);
+}
+
+TEST_F(MockICD, vkGetVideoSessionMemoryRequirementsKHR) {
+    auto vkGetVideoSessionMemoryRequirementsKHR = reinterpret_cast<PFN_vkGetVideoSessionMemoryRequirementsKHR>(
+        vkGetDeviceProcAddr(device, "vkGetVideoSessionMemoryRequirementsKHR"));
+    ASSERT_NE(vkGetVideoSessionMemoryRequirementsKHR, nullptr);
+
+    VkVideoSessionKHR video_session{};
+    uint32_t count = 0;
+    VkResult res = vkGetVideoSessionMemoryRequirementsKHR(device, video_session, &count, nullptr);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(count, 1);
+    VkVideoSessionMemoryRequirementsKHR memory_requirements{};
+    res = vkGetVideoSessionMemoryRequirementsKHR(device, video_session, &count, &memory_requirements);
+    ASSERT_EQ(res, VK_SUCCESS);
+    ASSERT_EQ(count, 1);
+    ASSERT_EQ(memory_requirements.memoryBindIndex, 0);
+    ASSERT_EQ(memory_requirements.memoryRequirements.size, 4096);
+    ASSERT_EQ(memory_requirements.memoryRequirements.alignment, 1);
+    ASSERT_EQ(memory_requirements.memoryRequirements.memoryTypeBits, 0xFFFF);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceVideoFormatPropertiesKHR) {
+    auto vkGetPhysicalDeviceVideoFormatPropertiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR>(
+        vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR"));
+    ASSERT_NE(vkGetPhysicalDeviceVideoFormatPropertiesKHR, nullptr);
+
+    VkVideoDecodeH264ProfileInfoKHR decode_h264_profile_info{};
+    decode_h264_profile_info.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR;
+    decode_h264_profile_info.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_BASELINE;
+    decode_h264_profile_info.pictureLayout = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR;
+    VkVideoProfileInfoKHR video_profile_info{};
+    video_profile_info.sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR;
+    video_profile_info.pNext = &decode_h264_profile_info;
+    video_profile_info.videoCodecOperation = VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR;
+    video_profile_info.chromaSubsampling = VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR;
+    video_profile_info.lumaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR;
+    video_profile_info.chromaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR;
+    VkVideoProfileListInfoKHR video_profile_list{};
+    video_profile_list.sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR;
+    video_profile_list.profileCount = 1;
+    video_profile_list.pProfiles = &video_profile_info;
+    VkPhysicalDeviceVideoFormatInfoKHR video_format_info{};
+    video_format_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR;
+    video_format_info.pNext = &video_profile_list;
+    uint32_t count = 0;
+    VkResult res = vkGetPhysicalDeviceVideoFormatPropertiesKHR(physical_device, &video_format_info, &count, nullptr);
+    ASSERT_EQ(res, VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR);
+}
+
+TEST_F(MockICD, vkGetPhysicalDeviceVideoCapabilitiesKHR) {
+    auto vkGetPhysicalDeviceVideoCapabilitiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR>(
+        vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR"));
+    ASSERT_NE(vkGetPhysicalDeviceVideoCapabilitiesKHR, nullptr);
+
+    VkVideoDecodeH264ProfileInfoKHR decode_h264_profile_info{};
+    decode_h264_profile_info.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR;
+    decode_h264_profile_info.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_BASELINE;
+    decode_h264_profile_info.pictureLayout = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR;
+    VkVideoProfileInfoKHR video_profile_info{};
+    video_profile_info.sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR;
+    video_profile_info.pNext = &decode_h264_profile_info;
+    video_profile_info.videoCodecOperation = VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR;
+    video_profile_info.chromaSubsampling = VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR;
+    video_profile_info.lumaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR;
+    video_profile_info.chromaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR;
+    VkVideoDecodeH264CapabilitiesKHR decode_h264_capabilities{};
+    decode_h264_capabilities.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR;
+    VkVideoDecodeCapabilitiesKHR decode_capabilities{};
+    decode_capabilities.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR;
+    decode_capabilities.pNext = &decode_h264_capabilities;
+    VkVideoCapabilitiesKHR video_capabilities{};
+    video_capabilities.sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR;
+    video_capabilities.pNext = &decode_capabilities;
+    VkResult res = vkGetPhysicalDeviceVideoCapabilitiesKHR(physical_device, &video_profile_info, &video_capabilities);
+    ASSERT_EQ(res, VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR);
+}
+
+TEST_F(MockICD, vkGetDescriptorSetLayoutSupport) {
+    VkDescriptorSetLayoutCreateInfo create_info{};
+    VkDescriptorSetLayoutSupport support{};
+    vkGetDescriptorSetLayoutSupport(device, &create_info, &support);
+    ASSERT_EQ(support.supported, VK_TRUE);
+}
+
+TEST_F(MockICD, vkGetDescriptorSetLayoutSupportKHR) {
+    auto vkGetDescriptorSetLayoutSupportKHR =
+        reinterpret_cast<PFN_vkGetDescriptorSetLayoutSupportKHR>(vkGetDeviceProcAddr(device, "vkGetDescriptorSetLayoutSupportKHR"));
+    ASSERT_NE(vkGetDescriptorSetLayoutSupportKHR, nullptr);
+
+    VkDescriptorSetLayoutCreateInfo create_info{};
+    VkDescriptorSetLayoutSupport support{};
+    vkGetDescriptorSetLayoutSupportKHR(device, &create_info, &support);
+    ASSERT_EQ(support.supported, VK_TRUE);
+}
+
+TEST_F(MockICD, vkGetRenderAreaGranularity) {
+    VkRenderPass render_pass{};
+    VkExtent2D granularity{};
+    vkGetRenderAreaGranularity(device, render_pass, &granularity);
+    ASSERT_EQ(granularity.width, 1);
+    ASSERT_EQ(granularity.height, 1);
+}
diff --git a/tools/Vulkan-Tools/tests/main.cpp b/tools/Vulkan-Tools/tests/main.cpp
new file mode 100644
index 00000000..31131426
--- /dev/null
+++ b/tools/Vulkan-Tools/tests/main.cpp
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2023 The Khronos Group Inc.
+ * Copyright (c) 2023 Valve Corporation
+ * Copyright (c) 2023 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#if defined(_WIN32) && !defined(NDEBUG)
+#include <crtdbg.h>
+#endif
+
+#include "gtest/gtest.h"
+
+int main(int argc, char **argv) {
+    int result;
+
+    ::testing::InitGoogleTest(&argc, argv);
+
+    result = RUN_ALL_TESTS();
+
+    return result;
+}
diff --git a/tools/Vulkan-Tools/tests/test_common.h b/tools/Vulkan-Tools/tests/test_common.h
new file mode 100644
index 00000000..72df9067
--- /dev/null
+++ b/tools/Vulkan-Tools/tests/test_common.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2023 The Khronos Group Inc.
+ * Copyright (c) 2023 Valve Corporation
+ * Copyright (c) 2023 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdlib.h>
+
+#include <array>
+#include <iostream>
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "vulkan/vulkan.h"
+
+#if defined(WIN32)
+#include <windows.h>
+inline int set_environment_var(const char* name, const char* value) { return SetEnvironmentVariable(name, value); }
+#else
+inline int set_environment_var(const char* name, const char* value) { return setenv(name, value, 1); }
+#endif
diff --git a/tools/Vulkan-Tools/vulkaninfo/BUILD.gn b/tools/Vulkan-Tools/vulkaninfo/BUILD.gn
new file mode 100644
index 00000000..9f460ca8
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/BUILD.gn
@@ -0,0 +1,78 @@
+# Copyright (C) 2025 The Fuchsia Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//build_overrides/vulkan_tools.gni")
+if (is_fuchsia) {
+  import("//build/components.gni")
+  import("//src/lib/vulkan/vulkan.gni")
+}
+
+config("vulkaninfo_warnings") {
+  cflags = [
+    "-Wno-conversion",
+    "-Wno-implicit-fallthrough",
+    "-Wno-missing-field-initializers",
+    "-Wno-extra-semi",
+    "-Wno-ambiguous-reversed-operator",
+  ]
+}
+
+executable("vulkaninfo") {
+  sources = [ "vulkaninfo.cpp" ]
+
+  include_dirs = [
+    ".",
+    "generated",
+  ]
+
+  deps = [ "$vulkan_headers_dir:vulkan_headers" ]
+  if (is_fuchsia) {
+    deps += [ "//third_party/Vulkan-Loader:libvulkan" ]
+  }
+
+  configs += [
+    ":vulkaninfo_warnings",
+  ]
+  if (is_fuchsia) {
+    configs -= [ "//build/config:no_exceptions" ]
+  }
+
+  defines = [
+    "VK_ENABLE_BETA_EXTENSIONS",
+    "VK_NO_PROTOTYPES",
+  ]
+}
+
+if (is_fuchsia) {
+  fuchsia_test_component("vulkaninfo-component") {
+    manifest = "fuchsia/meta/vulkaninfo.cml"
+    component_name = "vulkaninfo"
+
+    deps = [
+      ":vulkaninfo",
+      "//src/lib/vulkan/swapchain:image_pipe_swapchain_fb_layer",
+      "//src/lib/vulkan/validation_layers",
+    ]
+    test_type = "vulkan"
+  }
+
+  fuchsia_test_package("vulkaninfo-package") {
+    package_name = "vulkaninfo"
+    test_components = [ ":vulkaninfo-component" ]
+
+    test_specs = {
+      environments = vulkan_envs
+    }
+  }
+}
diff --git a/tools/Vulkan-Tools/vulkaninfo/CMakeLists.txt b/tools/Vulkan-Tools/vulkaninfo/CMakeLists.txt
new file mode 100644
index 00000000..ed61c89f
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/CMakeLists.txt
@@ -0,0 +1,130 @@
+# ~~~
+# Copyright (c) 2018-2023 Valve Corporation
+# Copyright (c) 2018-2023 LunarG, Inc.
+# Copyright (c) 2023-2023 RasterGrid Kft.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ~~~
+
+# These variables enable downstream users to customize the CMake targets
+# based on the target API variant (e.g. Vulkan SC)
+set(VULKANINFO_NAME vulkaninfo)
+set(GENERATED generated)
+
+add_executable(vulkaninfo)
+set_target_properties(vulkaninfo PROPERTIES OUTPUT_NAME ${VULKANINFO_NAME})
+
+target_sources(vulkaninfo PRIVATE vulkaninfo.cpp)
+
+# Setup the vulkaninfo.rc file to contain the correct info
+# Optionally uses the VULKANINFO_BUILD_DLL_VERSIONINFO build option to allow setting the exact build version
+# When VULKANINFO_BUILD_DLL_VERSIONINFO is not provided, "Dev Build" is added to the version strings
+if(WIN32)
+    set(VULKANINFO_BUILD_DLL_VERSIONINFO "default" CACHE STRING "Set the version to be used in the vulkaninfo.rc file")
+
+    string(TIMESTAMP CURRENT_YEAR "%Y")
+    set(VULKANINFO_CUR_COPYRIGHT_STR "${CURRENT_YEAR}")
+    if ("$CACHE{VULKANINFO_BUILD_DLL_VERSIONINFO}" STREQUAL "default")
+        message(DEBUG "Setting RC version based on VulkanHeaders Version")
+        set(VULKANINFO_RC_VERSION "${VulkanHeaders_VERSION}")
+        set(VULKANINFO_VER_FILE_VERSION_STR "\"${VULKANINFO_RC_VERSION}.Dev Build\"")
+        set(VULKANINFO_VER_FILE_DESCRIPTION_STR "\"Vulkaninfo - Dev Build\"")
+    else()
+        message(DEBUG "Setting RC version based on VULKANINFO_BUILD_DLL_VERSIONINFO")
+        set(VULKANINFO_RC_VERSION "$CACHE{VULKANINFO_BUILD_DLL_VERSIONINFO}")
+        set(VULKANINFO_VER_FILE_VERSION_STR "\"${VULKANINFO_RC_VERSION}\"")
+        set(VULKANINFO_VER_FILE_DESCRIPTION_STR "\"vulkaninfo\"")
+    endif()
+
+    # RC file wants the value of FILEVERSION to separated by commas
+    string(REPLACE "." ", " VULKANINFO_VER_FILE_VERSION "${VULKANINFO_RC_VERSION}")
+
+    # Configure the file to include the versioning info
+    configure_file(vulkaninfo.rc.in ${CMAKE_CURRENT_BINARY_DIR}/vulkaninfo.rc)
+
+    target_sources(vulkaninfo PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/vulkaninfo.rc)
+endif()
+
+target_include_directories(vulkaninfo PRIVATE
+    ${GENERATED}
+    .
+)
+
+target_compile_definitions(vulkaninfo PRIVATE VK_ENABLE_BETA_EXTENSIONS VK_NO_PROTOTYPES)
+
+if (CMAKE_SYSTEM_NAME MATCHES "Linux|BSD|GNU")
+    option(BUILD_WSI_XCB_SUPPORT "Build XCB WSI support" ON)
+    option(BUILD_WSI_XLIB_SUPPORT "Build Xlib WSI support" ON)
+    option(BUILD_WSI_WAYLAND_SUPPORT "Build Wayland WSI support" ON)
+    option(BUILD_WSI_DIRECTFB_SUPPORT "Build DirectFB WSI support" OFF)
+
+    find_package(PkgConfig REQUIRED QUIET) # Use PkgConfig to find Linux system libraries
+
+    if(BUILD_WSI_XCB_SUPPORT)
+        pkg_check_modules(XCB REQUIRED QUIET IMPORTED_TARGET xcb)
+        target_compile_definitions(vulkaninfo PRIVATE VK_USE_PLATFORM_XCB_KHR)
+        target_link_libraries(vulkaninfo PRIVATE PkgConfig::XCB)
+    endif()
+
+    if(BUILD_WSI_XLIB_SUPPORT)
+        pkg_check_modules(X11 REQUIRED QUIET IMPORTED_TARGET x11)
+        target_compile_definitions(vulkaninfo PRIVATE VK_USE_PLATFORM_XLIB_KHR)
+        target_link_libraries(vulkaninfo PRIVATE PkgConfig::X11)
+    endif()
+
+    if(BUILD_WSI_WAYLAND_SUPPORT)
+        pkg_check_modules(WAYLAND_CLIENT REQUIRED IMPORTED_TARGET wayland-client)
+        target_compile_definitions(vulkaninfo PRIVATE VK_USE_PLATFORM_WAYLAND_KHR)
+        target_link_libraries(vulkaninfo PRIVATE PkgConfig::WAYLAND_CLIENT)
+    endif()
+
+    if(BUILD_WSI_DIRECTFB_SUPPORT)
+        pkg_check_modules(DirectFB REQUIRED QUIET IMPORTED_TARGET directfb)
+        target_compile_definitions(vulkaninfo PRIVATE VK_USE_PLATFORM_DIRECTFB_EXT)
+        target_link_libraries(vulkaninfo PRIVATE PkgConfig::DirectFB)
+    endif()
+    target_compile_definitions(vulkaninfo PRIVATE VK_USE_PLATFORM_DISPLAY)
+endif()
+
+if(APPLE)
+    # We do this so vulkaninfo is linked to an individual library and NOT a framework.
+    target_link_libraries(vulkaninfo PRIVATE "-framework AppKit -framework QuartzCore")
+    target_include_directories(vulkaninfo PRIVATE macOS/vulkaninfo)
+
+    target_sources(vulkaninfo PRIVATE
+        macOS/vulkaninfo/metal_view.mm
+        macOS/vulkaninfo/metal_view.h
+    )
+endif()
+
+target_link_libraries(vulkaninfo PRIVATE
+    Vulkan::Headers
+    ${CMAKE_DL_LIBS}
+)
+
+if(WIN32)
+    target_compile_definitions(vulkaninfo PRIVATE
+        VK_USE_PLATFORM_WIN32_KHR
+        WIN32_LEAN_AND_MEAN
+        _CRT_SECURE_NO_WARNINGS
+    )
+elseif(APPLE)
+    target_compile_definitions(vulkaninfo PRIVATE VK_USE_PLATFORM_METAL_EXT)
+    if (IOS)
+        target_compile_definitions(vulkaninfo PRIVATE VK_USE_PLATFORM_IOS_MVK)
+    else()
+        target_compile_definitions(vulkaninfo PRIVATE VK_USE_PLATFORM_MACOS_MVK)
+    endif()
+endif()
+
+install(TARGETS vulkaninfo)
diff --git a/tools/Vulkan-Tools/vulkaninfo/fuchsia/meta/vulkaninfo.cml b/tools/Vulkan-Tools/vulkaninfo/fuchsia/meta/vulkaninfo.cml
new file mode 100644
index 00000000..c7908172
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/fuchsia/meta/vulkaninfo.cml
@@ -0,0 +1,23 @@
+// Copyright (C) 2025 The Fuchsia Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+{
+    include: [
+        "sys/testing/elf_test_runner.shard.cml",
+        "syslog/client.shard.cml",
+        "vulkan/client.shard.cml",
+    ],
+    program: {
+        binary: "bin/vulkaninfo",
+    },
+}
diff --git a/tools/Vulkan-Tools/vulkaninfo/generated/.clang-format b/tools/Vulkan-Tools/vulkaninfo/generated/.clang-format
new file mode 100644
index 00000000..3bb983a4
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/generated/.clang-format
@@ -0,0 +1,5 @@
+---
+# Disable clang-format for generated code
+DisableFormat: true
+SortIncludes: false
+...
diff --git a/tools/Vulkan-Tools/vulkaninfo/generated/vulkaninfo.hpp b/tools/Vulkan-Tools/vulkaninfo/generated/vulkaninfo.hpp
new file mode 100644
index 00000000..2aaa17bb
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/generated/vulkaninfo.hpp
@@ -0,0 +1,13708 @@
+
+/*
+ * Copyright (c) 2019-2026 The Khronos Group Inc.
+ * Copyright (c) 2019-2026 Valve Corporation
+ * Copyright (c) 2019-2026 LunarG, Inc.
+ * Copyright (c) 2023-2024 RasterGrid Kft.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Charles Giessen <charles@lunarg.com>
+ *
+ */
+
+/*
+ * This file is generated from the Khronos Vulkan XML API Registry.
+ */
+
+#include "vulkaninfo.h"
+#include "outputprinter.h"
+
+template <typename T>
+std::string to_hex_str(const T i) {
+    std::stringstream stream;
+    stream << "0x" << std::setfill('0') << std::setw(sizeof(T)) << std::hex << i;
+    return stream.str();
+}
+
+template <typename T>
+std::string to_hex_str(Printer &p, const T i) {
+    if (p.Type() == OutputType::json)
+        return std::to_string(i);
+    else if (p.Type() == OutputType::vkconfig_output)
+        return std::string("\"") + to_hex_str(i) + std::string("\"");
+    else
+        return to_hex_str(i);
+}
+
+std::string StdVideoH264ChromaFormatIdcString(StdVideoH264ChromaFormatIdc value) {
+    switch (value) {
+        case STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME:
+            return "STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME";
+        case STD_VIDEO_H264_CHROMA_FORMAT_IDC_420:
+            return "STD_VIDEO_H264_CHROMA_FORMAT_IDC_420";
+        case STD_VIDEO_H264_CHROMA_FORMAT_IDC_422:
+            return "STD_VIDEO_H264_CHROMA_FORMAT_IDC_422";
+        case STD_VIDEO_H264_CHROMA_FORMAT_IDC_444:
+            return "STD_VIDEO_H264_CHROMA_FORMAT_IDC_444";
+        case STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID:
+            return "STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264ChromaFormatIdc_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264ChromaFormatIdc(Printer &p, std::string name, StdVideoH264ChromaFormatIdc value) {
+    p.PrintKeyString(name, StdVideoH264ChromaFormatIdcString(value));
+}
+std::string StdVideoH264ProfileIdcString(StdVideoH264ProfileIdc value) {
+    switch (value) {
+        case STD_VIDEO_H264_PROFILE_IDC_BASELINE:
+            return "STD_VIDEO_H264_PROFILE_IDC_BASELINE";
+        case STD_VIDEO_H264_PROFILE_IDC_MAIN:
+            return "STD_VIDEO_H264_PROFILE_IDC_MAIN";
+        case STD_VIDEO_H264_PROFILE_IDC_HIGH:
+            return "STD_VIDEO_H264_PROFILE_IDC_HIGH";
+        case STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE:
+            return "STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE";
+        case STD_VIDEO_H264_PROFILE_IDC_INVALID:
+            return "STD_VIDEO_H264_PROFILE_IDC_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264ProfileIdc_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264ProfileIdc(Printer &p, std::string name, StdVideoH264ProfileIdc value) {
+    p.PrintKeyString(name, StdVideoH264ProfileIdcString(value));
+}
+std::string StdVideoH264LevelIdcString(StdVideoH264LevelIdc value) {
+    switch (value) {
+        case STD_VIDEO_H264_LEVEL_IDC_1_0:
+            return "STD_VIDEO_H264_LEVEL_IDC_1_0";
+        case STD_VIDEO_H264_LEVEL_IDC_1_1:
+            return "STD_VIDEO_H264_LEVEL_IDC_1_1";
+        case STD_VIDEO_H264_LEVEL_IDC_1_2:
+            return "STD_VIDEO_H264_LEVEL_IDC_1_2";
+        case STD_VIDEO_H264_LEVEL_IDC_1_3:
+            return "STD_VIDEO_H264_LEVEL_IDC_1_3";
+        case STD_VIDEO_H264_LEVEL_IDC_2_0:
+            return "STD_VIDEO_H264_LEVEL_IDC_2_0";
+        case STD_VIDEO_H264_LEVEL_IDC_2_1:
+            return "STD_VIDEO_H264_LEVEL_IDC_2_1";
+        case STD_VIDEO_H264_LEVEL_IDC_2_2:
+            return "STD_VIDEO_H264_LEVEL_IDC_2_2";
+        case STD_VIDEO_H264_LEVEL_IDC_3_0:
+            return "STD_VIDEO_H264_LEVEL_IDC_3_0";
+        case STD_VIDEO_H264_LEVEL_IDC_3_1:
+            return "STD_VIDEO_H264_LEVEL_IDC_3_1";
+        case STD_VIDEO_H264_LEVEL_IDC_3_2:
+            return "STD_VIDEO_H264_LEVEL_IDC_3_2";
+        case STD_VIDEO_H264_LEVEL_IDC_4_0:
+            return "STD_VIDEO_H264_LEVEL_IDC_4_0";
+        case STD_VIDEO_H264_LEVEL_IDC_4_1:
+            return "STD_VIDEO_H264_LEVEL_IDC_4_1";
+        case STD_VIDEO_H264_LEVEL_IDC_4_2:
+            return "STD_VIDEO_H264_LEVEL_IDC_4_2";
+        case STD_VIDEO_H264_LEVEL_IDC_5_0:
+            return "STD_VIDEO_H264_LEVEL_IDC_5_0";
+        case STD_VIDEO_H264_LEVEL_IDC_5_1:
+            return "STD_VIDEO_H264_LEVEL_IDC_5_1";
+        case STD_VIDEO_H264_LEVEL_IDC_5_2:
+            return "STD_VIDEO_H264_LEVEL_IDC_5_2";
+        case STD_VIDEO_H264_LEVEL_IDC_6_0:
+            return "STD_VIDEO_H264_LEVEL_IDC_6_0";
+        case STD_VIDEO_H264_LEVEL_IDC_6_1:
+            return "STD_VIDEO_H264_LEVEL_IDC_6_1";
+        case STD_VIDEO_H264_LEVEL_IDC_6_2:
+            return "STD_VIDEO_H264_LEVEL_IDC_6_2";
+        case STD_VIDEO_H264_LEVEL_IDC_INVALID:
+            return "STD_VIDEO_H264_LEVEL_IDC_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264LevelIdc_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264LevelIdc(Printer &p, std::string name, StdVideoH264LevelIdc value) {
+    p.PrintKeyString(name, StdVideoH264LevelIdcString(value));
+}
+std::string StdVideoH264PocTypeString(StdVideoH264PocType value) {
+    switch (value) {
+        case STD_VIDEO_H264_POC_TYPE_0:
+            return "STD_VIDEO_H264_POC_TYPE_0";
+        case STD_VIDEO_H264_POC_TYPE_1:
+            return "STD_VIDEO_H264_POC_TYPE_1";
+        case STD_VIDEO_H264_POC_TYPE_2:
+            return "STD_VIDEO_H264_POC_TYPE_2";
+        case STD_VIDEO_H264_POC_TYPE_INVALID:
+            return "STD_VIDEO_H264_POC_TYPE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264PocType_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264PocType(Printer &p, std::string name, StdVideoH264PocType value) {
+    p.PrintKeyString(name, StdVideoH264PocTypeString(value));
+}
+std::string StdVideoH264AspectRatioIdcString(StdVideoH264AspectRatioIdc value) {
+    switch (value) {
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR";
+        case STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID:
+            return "STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264AspectRatioIdc_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264AspectRatioIdc(Printer &p, std::string name, StdVideoH264AspectRatioIdc value) {
+    p.PrintKeyString(name, StdVideoH264AspectRatioIdcString(value));
+}
+std::string StdVideoH264WeightedBipredIdcString(StdVideoH264WeightedBipredIdc value) {
+    switch (value) {
+        case STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT:
+            return "STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT";
+        case STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT:
+            return "STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT";
+        case STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT:
+            return "STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT";
+        case STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID:
+            return "STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264WeightedBipredIdc_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264WeightedBipredIdc(Printer &p, std::string name, StdVideoH264WeightedBipredIdc value) {
+    p.PrintKeyString(name, StdVideoH264WeightedBipredIdcString(value));
+}
+std::string StdVideoH264ModificationOfPicNumsIdcString(StdVideoH264ModificationOfPicNumsIdc value) {
+    switch (value) {
+        case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT:
+            return "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT";
+        case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD:
+            return "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD";
+        case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM:
+            return "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM";
+        case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END:
+            return "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END";
+        case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID:
+            return "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264ModificationOfPicNumsIdc_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264ModificationOfPicNumsIdc(Printer &p, std::string name, StdVideoH264ModificationOfPicNumsIdc value) {
+    p.PrintKeyString(name, StdVideoH264ModificationOfPicNumsIdcString(value));
+}
+std::string StdVideoH264MemMgmtControlOpString(StdVideoH264MemMgmtControlOp value) {
+    switch (value) {
+        case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END:
+            return "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END";
+        case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM:
+            return "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM";
+        case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM:
+            return "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM";
+        case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM:
+            return "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM";
+        case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX:
+            return "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX";
+        case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL:
+            return "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL";
+        case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM:
+            return "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM";
+        case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID:
+            return "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264MemMgmtControlOp_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264MemMgmtControlOp(Printer &p, std::string name, StdVideoH264MemMgmtControlOp value) {
+    p.PrintKeyString(name, StdVideoH264MemMgmtControlOpString(value));
+}
+std::string StdVideoH264CabacInitIdcString(StdVideoH264CabacInitIdc value) {
+    switch (value) {
+        case STD_VIDEO_H264_CABAC_INIT_IDC_0:
+            return "STD_VIDEO_H264_CABAC_INIT_IDC_0";
+        case STD_VIDEO_H264_CABAC_INIT_IDC_1:
+            return "STD_VIDEO_H264_CABAC_INIT_IDC_1";
+        case STD_VIDEO_H264_CABAC_INIT_IDC_2:
+            return "STD_VIDEO_H264_CABAC_INIT_IDC_2";
+        case STD_VIDEO_H264_CABAC_INIT_IDC_INVALID:
+            return "STD_VIDEO_H264_CABAC_INIT_IDC_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264CabacInitIdc_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264CabacInitIdc(Printer &p, std::string name, StdVideoH264CabacInitIdc value) {
+    p.PrintKeyString(name, StdVideoH264CabacInitIdcString(value));
+}
+std::string StdVideoH264DisableDeblockingFilterIdcString(StdVideoH264DisableDeblockingFilterIdc value) {
+    switch (value) {
+        case STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED:
+            return "STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED";
+        case STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED:
+            return "STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED";
+        case STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL:
+            return "STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL";
+        case STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID:
+            return "STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264DisableDeblockingFilterIdc_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264DisableDeblockingFilterIdc(Printer &p, std::string name, StdVideoH264DisableDeblockingFilterIdc value) {
+    p.PrintKeyString(name, StdVideoH264DisableDeblockingFilterIdcString(value));
+}
+std::string StdVideoH264SliceTypeString(StdVideoH264SliceType value) {
+    switch (value) {
+        case STD_VIDEO_H264_SLICE_TYPE_P:
+            return "STD_VIDEO_H264_SLICE_TYPE_P";
+        case STD_VIDEO_H264_SLICE_TYPE_B:
+            return "STD_VIDEO_H264_SLICE_TYPE_B";
+        case STD_VIDEO_H264_SLICE_TYPE_I:
+            return "STD_VIDEO_H264_SLICE_TYPE_I";
+        case STD_VIDEO_H264_SLICE_TYPE_INVALID:
+            return "STD_VIDEO_H264_SLICE_TYPE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264SliceType_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264SliceType(Printer &p, std::string name, StdVideoH264SliceType value) {
+    p.PrintKeyString(name, StdVideoH264SliceTypeString(value));
+}
+std::string StdVideoH264PictureTypeString(StdVideoH264PictureType value) {
+    switch (value) {
+        case STD_VIDEO_H264_PICTURE_TYPE_P:
+            return "STD_VIDEO_H264_PICTURE_TYPE_P";
+        case STD_VIDEO_H264_PICTURE_TYPE_B:
+            return "STD_VIDEO_H264_PICTURE_TYPE_B";
+        case STD_VIDEO_H264_PICTURE_TYPE_I:
+            return "STD_VIDEO_H264_PICTURE_TYPE_I";
+        case STD_VIDEO_H264_PICTURE_TYPE_IDR:
+            return "STD_VIDEO_H264_PICTURE_TYPE_IDR";
+        case STD_VIDEO_H264_PICTURE_TYPE_INVALID:
+            return "STD_VIDEO_H264_PICTURE_TYPE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264PictureType_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264PictureType(Printer &p, std::string name, StdVideoH264PictureType value) {
+    p.PrintKeyString(name, StdVideoH264PictureTypeString(value));
+}
+std::string StdVideoH264NonVclNaluTypeString(StdVideoH264NonVclNaluType value) {
+    switch (value) {
+        case STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS:
+            return "STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS";
+        case STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS:
+            return "STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS";
+        case STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD:
+            return "STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD";
+        case STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX:
+            return "STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX";
+        case STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE:
+            return "STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE";
+        case STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM:
+            return "STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM";
+        case STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED:
+            return "STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED";
+        case STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID:
+            return "STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH264NonVclNaluType_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH264NonVclNaluType(Printer &p, std::string name, StdVideoH264NonVclNaluType value) {
+    p.PrintKeyString(name, StdVideoH264NonVclNaluTypeString(value));
+}
+std::string StdVideoDecodeH264FieldOrderCountString(StdVideoDecodeH264FieldOrderCount value) {
+    switch (value) {
+        case STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP:
+            return "STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP";
+        case STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM:
+            return "STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM";
+        case STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID:
+            return "STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoDecodeH264FieldOrderCount_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoDecodeH264FieldOrderCount(Printer &p, std::string name, StdVideoDecodeH264FieldOrderCount value) {
+    p.PrintKeyString(name, StdVideoDecodeH264FieldOrderCountString(value));
+}
+std::string StdVideoH265ChromaFormatIdcString(StdVideoH265ChromaFormatIdc value) {
+    switch (value) {
+        case STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME:
+            return "STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME";
+        case STD_VIDEO_H265_CHROMA_FORMAT_IDC_420:
+            return "STD_VIDEO_H265_CHROMA_FORMAT_IDC_420";
+        case STD_VIDEO_H265_CHROMA_FORMAT_IDC_422:
+            return "STD_VIDEO_H265_CHROMA_FORMAT_IDC_422";
+        case STD_VIDEO_H265_CHROMA_FORMAT_IDC_444:
+            return "STD_VIDEO_H265_CHROMA_FORMAT_IDC_444";
+        case STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID:
+            return "STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH265ChromaFormatIdc_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH265ChromaFormatIdc(Printer &p, std::string name, StdVideoH265ChromaFormatIdc value) {
+    p.PrintKeyString(name, StdVideoH265ChromaFormatIdcString(value));
+}
+std::string StdVideoH265ProfileIdcString(StdVideoH265ProfileIdc value) {
+    switch (value) {
+        case STD_VIDEO_H265_PROFILE_IDC_MAIN:
+            return "STD_VIDEO_H265_PROFILE_IDC_MAIN";
+        case STD_VIDEO_H265_PROFILE_IDC_MAIN_10:
+            return "STD_VIDEO_H265_PROFILE_IDC_MAIN_10";
+        case STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE:
+            return "STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE";
+        case STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS:
+            return "STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS";
+        case STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS:
+            return "STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS";
+        case STD_VIDEO_H265_PROFILE_IDC_INVALID:
+            return "STD_VIDEO_H265_PROFILE_IDC_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH265ProfileIdc_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH265ProfileIdc(Printer &p, std::string name, StdVideoH265ProfileIdc value) {
+    p.PrintKeyString(name, StdVideoH265ProfileIdcString(value));
+}
+std::string StdVideoH265LevelIdcString(StdVideoH265LevelIdc value) {
+    switch (value) {
+        case STD_VIDEO_H265_LEVEL_IDC_1_0:
+            return "STD_VIDEO_H265_LEVEL_IDC_1_0";
+        case STD_VIDEO_H265_LEVEL_IDC_2_0:
+            return "STD_VIDEO_H265_LEVEL_IDC_2_0";
+        case STD_VIDEO_H265_LEVEL_IDC_2_1:
+            return "STD_VIDEO_H265_LEVEL_IDC_2_1";
+        case STD_VIDEO_H265_LEVEL_IDC_3_0:
+            return "STD_VIDEO_H265_LEVEL_IDC_3_0";
+        case STD_VIDEO_H265_LEVEL_IDC_3_1:
+            return "STD_VIDEO_H265_LEVEL_IDC_3_1";
+        case STD_VIDEO_H265_LEVEL_IDC_4_0:
+            return "STD_VIDEO_H265_LEVEL_IDC_4_0";
+        case STD_VIDEO_H265_LEVEL_IDC_4_1:
+            return "STD_VIDEO_H265_LEVEL_IDC_4_1";
+        case STD_VIDEO_H265_LEVEL_IDC_5_0:
+            return "STD_VIDEO_H265_LEVEL_IDC_5_0";
+        case STD_VIDEO_H265_LEVEL_IDC_5_1:
+            return "STD_VIDEO_H265_LEVEL_IDC_5_1";
+        case STD_VIDEO_H265_LEVEL_IDC_5_2:
+            return "STD_VIDEO_H265_LEVEL_IDC_5_2";
+        case STD_VIDEO_H265_LEVEL_IDC_6_0:
+            return "STD_VIDEO_H265_LEVEL_IDC_6_0";
+        case STD_VIDEO_H265_LEVEL_IDC_6_1:
+            return "STD_VIDEO_H265_LEVEL_IDC_6_1";
+        case STD_VIDEO_H265_LEVEL_IDC_6_2:
+            return "STD_VIDEO_H265_LEVEL_IDC_6_2";
+        case STD_VIDEO_H265_LEVEL_IDC_INVALID:
+            return "STD_VIDEO_H265_LEVEL_IDC_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH265LevelIdc_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH265LevelIdc(Printer &p, std::string name, StdVideoH265LevelIdc value) {
+    p.PrintKeyString(name, StdVideoH265LevelIdcString(value));
+}
+std::string StdVideoH265SliceTypeString(StdVideoH265SliceType value) {
+    switch (value) {
+        case STD_VIDEO_H265_SLICE_TYPE_B:
+            return "STD_VIDEO_H265_SLICE_TYPE_B";
+        case STD_VIDEO_H265_SLICE_TYPE_P:
+            return "STD_VIDEO_H265_SLICE_TYPE_P";
+        case STD_VIDEO_H265_SLICE_TYPE_I:
+            return "STD_VIDEO_H265_SLICE_TYPE_I";
+        case STD_VIDEO_H265_SLICE_TYPE_INVALID:
+            return "STD_VIDEO_H265_SLICE_TYPE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH265SliceType_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH265SliceType(Printer &p, std::string name, StdVideoH265SliceType value) {
+    p.PrintKeyString(name, StdVideoH265SliceTypeString(value));
+}
+std::string StdVideoH265PictureTypeString(StdVideoH265PictureType value) {
+    switch (value) {
+        case STD_VIDEO_H265_PICTURE_TYPE_P:
+            return "STD_VIDEO_H265_PICTURE_TYPE_P";
+        case STD_VIDEO_H265_PICTURE_TYPE_B:
+            return "STD_VIDEO_H265_PICTURE_TYPE_B";
+        case STD_VIDEO_H265_PICTURE_TYPE_I:
+            return "STD_VIDEO_H265_PICTURE_TYPE_I";
+        case STD_VIDEO_H265_PICTURE_TYPE_IDR:
+            return "STD_VIDEO_H265_PICTURE_TYPE_IDR";
+        case STD_VIDEO_H265_PICTURE_TYPE_INVALID:
+            return "STD_VIDEO_H265_PICTURE_TYPE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH265PictureType_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH265PictureType(Printer &p, std::string name, StdVideoH265PictureType value) {
+    p.PrintKeyString(name, StdVideoH265PictureTypeString(value));
+}
+std::string StdVideoH265AspectRatioIdcString(StdVideoH265AspectRatioIdc value) {
+    switch (value) {
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR";
+        case STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID:
+            return "STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoH265AspectRatioIdc_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoH265AspectRatioIdc(Printer &p, std::string name, StdVideoH265AspectRatioIdc value) {
+    p.PrintKeyString(name, StdVideoH265AspectRatioIdcString(value));
+}
+std::string StdVideoAV1ProfileString(StdVideoAV1Profile value) {
+    switch (value) {
+        case STD_VIDEO_AV1_PROFILE_MAIN:
+            return "STD_VIDEO_AV1_PROFILE_MAIN";
+        case STD_VIDEO_AV1_PROFILE_HIGH:
+            return "STD_VIDEO_AV1_PROFILE_HIGH";
+        case STD_VIDEO_AV1_PROFILE_PROFESSIONAL:
+            return "STD_VIDEO_AV1_PROFILE_PROFESSIONAL";
+        case STD_VIDEO_AV1_PROFILE_INVALID:
+            return "STD_VIDEO_AV1_PROFILE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoAV1Profile_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoAV1Profile(Printer &p, std::string name, StdVideoAV1Profile value) {
+    p.PrintKeyString(name, StdVideoAV1ProfileString(value));
+}
+std::string StdVideoAV1LevelString(StdVideoAV1Level value) {
+    switch (value) {
+        case STD_VIDEO_AV1_LEVEL_2_0:
+            return "STD_VIDEO_AV1_LEVEL_2_0";
+        case STD_VIDEO_AV1_LEVEL_2_1:
+            return "STD_VIDEO_AV1_LEVEL_2_1";
+        case STD_VIDEO_AV1_LEVEL_2_2:
+            return "STD_VIDEO_AV1_LEVEL_2_2";
+        case STD_VIDEO_AV1_LEVEL_2_3:
+            return "STD_VIDEO_AV1_LEVEL_2_3";
+        case STD_VIDEO_AV1_LEVEL_3_0:
+            return "STD_VIDEO_AV1_LEVEL_3_0";
+        case STD_VIDEO_AV1_LEVEL_3_1:
+            return "STD_VIDEO_AV1_LEVEL_3_1";
+        case STD_VIDEO_AV1_LEVEL_3_2:
+            return "STD_VIDEO_AV1_LEVEL_3_2";
+        case STD_VIDEO_AV1_LEVEL_3_3:
+            return "STD_VIDEO_AV1_LEVEL_3_3";
+        case STD_VIDEO_AV1_LEVEL_4_0:
+            return "STD_VIDEO_AV1_LEVEL_4_0";
+        case STD_VIDEO_AV1_LEVEL_4_1:
+            return "STD_VIDEO_AV1_LEVEL_4_1";
+        case STD_VIDEO_AV1_LEVEL_4_2:
+            return "STD_VIDEO_AV1_LEVEL_4_2";
+        case STD_VIDEO_AV1_LEVEL_4_3:
+            return "STD_VIDEO_AV1_LEVEL_4_3";
+        case STD_VIDEO_AV1_LEVEL_5_0:
+            return "STD_VIDEO_AV1_LEVEL_5_0";
+        case STD_VIDEO_AV1_LEVEL_5_1:
+            return "STD_VIDEO_AV1_LEVEL_5_1";
+        case STD_VIDEO_AV1_LEVEL_5_2:
+            return "STD_VIDEO_AV1_LEVEL_5_2";
+        case STD_VIDEO_AV1_LEVEL_5_3:
+            return "STD_VIDEO_AV1_LEVEL_5_3";
+        case STD_VIDEO_AV1_LEVEL_6_0:
+            return "STD_VIDEO_AV1_LEVEL_6_0";
+        case STD_VIDEO_AV1_LEVEL_6_1:
+            return "STD_VIDEO_AV1_LEVEL_6_1";
+        case STD_VIDEO_AV1_LEVEL_6_2:
+            return "STD_VIDEO_AV1_LEVEL_6_2";
+        case STD_VIDEO_AV1_LEVEL_6_3:
+            return "STD_VIDEO_AV1_LEVEL_6_3";
+        case STD_VIDEO_AV1_LEVEL_7_0:
+            return "STD_VIDEO_AV1_LEVEL_7_0";
+        case STD_VIDEO_AV1_LEVEL_7_1:
+            return "STD_VIDEO_AV1_LEVEL_7_1";
+        case STD_VIDEO_AV1_LEVEL_7_2:
+            return "STD_VIDEO_AV1_LEVEL_7_2";
+        case STD_VIDEO_AV1_LEVEL_7_3:
+            return "STD_VIDEO_AV1_LEVEL_7_3";
+        case STD_VIDEO_AV1_LEVEL_INVALID:
+            return "STD_VIDEO_AV1_LEVEL_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoAV1Level_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoAV1Level(Printer &p, std::string name, StdVideoAV1Level value) {
+    p.PrintKeyString(name, StdVideoAV1LevelString(value));
+}
+std::string StdVideoAV1FrameTypeString(StdVideoAV1FrameType value) {
+    switch (value) {
+        case STD_VIDEO_AV1_FRAME_TYPE_KEY:
+            return "STD_VIDEO_AV1_FRAME_TYPE_KEY";
+        case STD_VIDEO_AV1_FRAME_TYPE_INTER:
+            return "STD_VIDEO_AV1_FRAME_TYPE_INTER";
+        case STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY:
+            return "STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY";
+        case STD_VIDEO_AV1_FRAME_TYPE_SWITCH:
+            return "STD_VIDEO_AV1_FRAME_TYPE_SWITCH";
+        case STD_VIDEO_AV1_FRAME_TYPE_INVALID:
+            return "STD_VIDEO_AV1_FRAME_TYPE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoAV1FrameType_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoAV1FrameType(Printer &p, std::string name, StdVideoAV1FrameType value) {
+    p.PrintKeyString(name, StdVideoAV1FrameTypeString(value));
+}
+std::string StdVideoAV1ReferenceNameString(StdVideoAV1ReferenceName value) {
+    switch (value) {
+        case STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME:
+            return "STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME";
+        case STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME:
+            return "STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME";
+        case STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME:
+            return "STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME";
+        case STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME:
+            return "STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME";
+        case STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME:
+            return "STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME";
+        case STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME:
+            return "STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME";
+        case STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME:
+            return "STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME";
+        case STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME:
+            return "STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME";
+        case STD_VIDEO_AV1_REFERENCE_NAME_INVALID:
+            return "STD_VIDEO_AV1_REFERENCE_NAME_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoAV1ReferenceName_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoAV1ReferenceName(Printer &p, std::string name, StdVideoAV1ReferenceName value) {
+    p.PrintKeyString(name, StdVideoAV1ReferenceNameString(value));
+}
+std::string StdVideoAV1InterpolationFilterString(StdVideoAV1InterpolationFilter value) {
+    switch (value) {
+        case STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP:
+            return "STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP";
+        case STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH:
+            return "STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH";
+        case STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP:
+            return "STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP";
+        case STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR:
+            return "STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR";
+        case STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE:
+            return "STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE";
+        case STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID:
+            return "STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoAV1InterpolationFilter_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoAV1InterpolationFilter(Printer &p, std::string name, StdVideoAV1InterpolationFilter value) {
+    p.PrintKeyString(name, StdVideoAV1InterpolationFilterString(value));
+}
+std::string StdVideoAV1TxModeString(StdVideoAV1TxMode value) {
+    switch (value) {
+        case STD_VIDEO_AV1_TX_MODE_ONLY_4X4:
+            return "STD_VIDEO_AV1_TX_MODE_ONLY_4X4";
+        case STD_VIDEO_AV1_TX_MODE_LARGEST:
+            return "STD_VIDEO_AV1_TX_MODE_LARGEST";
+        case STD_VIDEO_AV1_TX_MODE_SELECT:
+            return "STD_VIDEO_AV1_TX_MODE_SELECT";
+        case STD_VIDEO_AV1_TX_MODE_INVALID:
+            return "STD_VIDEO_AV1_TX_MODE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoAV1TxMode_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoAV1TxMode(Printer &p, std::string name, StdVideoAV1TxMode value) {
+    p.PrintKeyString(name, StdVideoAV1TxModeString(value));
+}
+std::string StdVideoAV1FrameRestorationTypeString(StdVideoAV1FrameRestorationType value) {
+    switch (value) {
+        case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE:
+            return "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE";
+        case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER:
+            return "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER";
+        case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ:
+            return "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ";
+        case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE:
+            return "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE";
+        case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID:
+            return "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoAV1FrameRestorationType_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoAV1FrameRestorationType(Printer &p, std::string name, StdVideoAV1FrameRestorationType value) {
+    p.PrintKeyString(name, StdVideoAV1FrameRestorationTypeString(value));
+}
+std::string StdVideoAV1ColorPrimariesString(StdVideoAV1ColorPrimaries value) {
+    switch (value) {
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709";
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED";
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M";
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G";
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601";
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240";
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM";
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020";
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ";
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431";
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432";
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213";
+        case STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID:
+            return "STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoAV1ColorPrimaries_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoAV1ColorPrimaries(Printer &p, std::string name, StdVideoAV1ColorPrimaries value) {
+    p.PrintKeyString(name, StdVideoAV1ColorPrimariesString(value));
+}
+std::string StdVideoAV1TransferCharacteristicsString(StdVideoAV1TransferCharacteristics value) {
+    switch (value) {
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG";
+        case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID:
+            return "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoAV1TransferCharacteristics_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoAV1TransferCharacteristics(Printer &p, std::string name, StdVideoAV1TransferCharacteristics value) {
+    p.PrintKeyString(name, StdVideoAV1TransferCharacteristicsString(value));
+}
+std::string StdVideoAV1MatrixCoefficientsString(StdVideoAV1MatrixCoefficients value) {
+    switch (value) {
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP";
+        case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID:
+            return "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoAV1MatrixCoefficients_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoAV1MatrixCoefficients(Printer &p, std::string name, StdVideoAV1MatrixCoefficients value) {
+    p.PrintKeyString(name, StdVideoAV1MatrixCoefficientsString(value));
+}
+std::string StdVideoAV1ChromaSamplePositionString(StdVideoAV1ChromaSamplePosition value) {
+    switch (value) {
+        case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN:
+            return "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN";
+        case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL:
+            return "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL";
+        case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED:
+            return "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED";
+        case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED:
+            return "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED";
+        case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID:
+            return "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoAV1ChromaSamplePosition_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoAV1ChromaSamplePosition(Printer &p, std::string name, StdVideoAV1ChromaSamplePosition value) {
+    p.PrintKeyString(name, StdVideoAV1ChromaSamplePositionString(value));
+}
+std::string StdVideoVP9ProfileString(StdVideoVP9Profile value) {
+    switch (value) {
+        case STD_VIDEO_VP9_PROFILE_0:
+            return "STD_VIDEO_VP9_PROFILE_0";
+        case STD_VIDEO_VP9_PROFILE_1:
+            return "STD_VIDEO_VP9_PROFILE_1";
+        case STD_VIDEO_VP9_PROFILE_2:
+            return "STD_VIDEO_VP9_PROFILE_2";
+        case STD_VIDEO_VP9_PROFILE_3:
+            return "STD_VIDEO_VP9_PROFILE_3";
+        case STD_VIDEO_VP9_PROFILE_INVALID:
+            return "STD_VIDEO_VP9_PROFILE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoVP9Profile_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoVP9Profile(Printer &p, std::string name, StdVideoVP9Profile value) {
+    p.PrintKeyString(name, StdVideoVP9ProfileString(value));
+}
+std::string StdVideoVP9LevelString(StdVideoVP9Level value) {
+    switch (value) {
+        case STD_VIDEO_VP9_LEVEL_1_0:
+            return "STD_VIDEO_VP9_LEVEL_1_0";
+        case STD_VIDEO_VP9_LEVEL_1_1:
+            return "STD_VIDEO_VP9_LEVEL_1_1";
+        case STD_VIDEO_VP9_LEVEL_2_0:
+            return "STD_VIDEO_VP9_LEVEL_2_0";
+        case STD_VIDEO_VP9_LEVEL_2_1:
+            return "STD_VIDEO_VP9_LEVEL_2_1";
+        case STD_VIDEO_VP9_LEVEL_3_0:
+            return "STD_VIDEO_VP9_LEVEL_3_0";
+        case STD_VIDEO_VP9_LEVEL_3_1:
+            return "STD_VIDEO_VP9_LEVEL_3_1";
+        case STD_VIDEO_VP9_LEVEL_4_0:
+            return "STD_VIDEO_VP9_LEVEL_4_0";
+        case STD_VIDEO_VP9_LEVEL_4_1:
+            return "STD_VIDEO_VP9_LEVEL_4_1";
+        case STD_VIDEO_VP9_LEVEL_5_0:
+            return "STD_VIDEO_VP9_LEVEL_5_0";
+        case STD_VIDEO_VP9_LEVEL_5_1:
+            return "STD_VIDEO_VP9_LEVEL_5_1";
+        case STD_VIDEO_VP9_LEVEL_5_2:
+            return "STD_VIDEO_VP9_LEVEL_5_2";
+        case STD_VIDEO_VP9_LEVEL_6_0:
+            return "STD_VIDEO_VP9_LEVEL_6_0";
+        case STD_VIDEO_VP9_LEVEL_6_1:
+            return "STD_VIDEO_VP9_LEVEL_6_1";
+        case STD_VIDEO_VP9_LEVEL_6_2:
+            return "STD_VIDEO_VP9_LEVEL_6_2";
+        case STD_VIDEO_VP9_LEVEL_INVALID:
+            return "STD_VIDEO_VP9_LEVEL_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoVP9Level_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoVP9Level(Printer &p, std::string name, StdVideoVP9Level value) {
+    p.PrintKeyString(name, StdVideoVP9LevelString(value));
+}
+std::string StdVideoVP9FrameTypeString(StdVideoVP9FrameType value) {
+    switch (value) {
+        case STD_VIDEO_VP9_FRAME_TYPE_KEY:
+            return "STD_VIDEO_VP9_FRAME_TYPE_KEY";
+        case STD_VIDEO_VP9_FRAME_TYPE_NON_KEY:
+            return "STD_VIDEO_VP9_FRAME_TYPE_NON_KEY";
+        case STD_VIDEO_VP9_FRAME_TYPE_INVALID:
+            return "STD_VIDEO_VP9_FRAME_TYPE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoVP9FrameType_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoVP9FrameType(Printer &p, std::string name, StdVideoVP9FrameType value) {
+    p.PrintKeyString(name, StdVideoVP9FrameTypeString(value));
+}
+std::string StdVideoVP9ReferenceNameString(StdVideoVP9ReferenceName value) {
+    switch (value) {
+        case STD_VIDEO_VP9_REFERENCE_NAME_INTRA_FRAME:
+            return "STD_VIDEO_VP9_REFERENCE_NAME_INTRA_FRAME";
+        case STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME:
+            return "STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME";
+        case STD_VIDEO_VP9_REFERENCE_NAME_GOLDEN_FRAME:
+            return "STD_VIDEO_VP9_REFERENCE_NAME_GOLDEN_FRAME";
+        case STD_VIDEO_VP9_REFERENCE_NAME_ALTREF_FRAME:
+            return "STD_VIDEO_VP9_REFERENCE_NAME_ALTREF_FRAME";
+        case STD_VIDEO_VP9_REFERENCE_NAME_INVALID:
+            return "STD_VIDEO_VP9_REFERENCE_NAME_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoVP9ReferenceName_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoVP9ReferenceName(Printer &p, std::string name, StdVideoVP9ReferenceName value) {
+    p.PrintKeyString(name, StdVideoVP9ReferenceNameString(value));
+}
+std::string StdVideoVP9InterpolationFilterString(StdVideoVP9InterpolationFilter value) {
+    switch (value) {
+        case STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP:
+            return "STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP";
+        case STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH:
+            return "STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH";
+        case STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SHARP:
+            return "STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SHARP";
+        case STD_VIDEO_VP9_INTERPOLATION_FILTER_BILINEAR:
+            return "STD_VIDEO_VP9_INTERPOLATION_FILTER_BILINEAR";
+        case STD_VIDEO_VP9_INTERPOLATION_FILTER_SWITCHABLE:
+            return "STD_VIDEO_VP9_INTERPOLATION_FILTER_SWITCHABLE";
+        case STD_VIDEO_VP9_INTERPOLATION_FILTER_INVALID:
+            return "STD_VIDEO_VP9_INTERPOLATION_FILTER_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoVP9InterpolationFilter_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoVP9InterpolationFilter(Printer &p, std::string name, StdVideoVP9InterpolationFilter value) {
+    p.PrintKeyString(name, StdVideoVP9InterpolationFilterString(value));
+}
+std::string StdVideoVP9ColorSpaceString(StdVideoVP9ColorSpace value) {
+    switch (value) {
+        case STD_VIDEO_VP9_COLOR_SPACE_UNKNOWN:
+            return "STD_VIDEO_VP9_COLOR_SPACE_UNKNOWN";
+        case STD_VIDEO_VP9_COLOR_SPACE_BT_601:
+            return "STD_VIDEO_VP9_COLOR_SPACE_BT_601";
+        case STD_VIDEO_VP9_COLOR_SPACE_BT_709:
+            return "STD_VIDEO_VP9_COLOR_SPACE_BT_709";
+        case STD_VIDEO_VP9_COLOR_SPACE_SMPTE_170:
+            return "STD_VIDEO_VP9_COLOR_SPACE_SMPTE_170";
+        case STD_VIDEO_VP9_COLOR_SPACE_SMPTE_240:
+            return "STD_VIDEO_VP9_COLOR_SPACE_SMPTE_240";
+        case STD_VIDEO_VP9_COLOR_SPACE_BT_2020:
+            return "STD_VIDEO_VP9_COLOR_SPACE_BT_2020";
+        case STD_VIDEO_VP9_COLOR_SPACE_RESERVED:
+            return "STD_VIDEO_VP9_COLOR_SPACE_RESERVED";
+        case STD_VIDEO_VP9_COLOR_SPACE_RGB:
+            return "STD_VIDEO_VP9_COLOR_SPACE_RGB";
+        case STD_VIDEO_VP9_COLOR_SPACE_INVALID:
+            return "STD_VIDEO_VP9_COLOR_SPACE_INVALID";
+        default:
+            return std::string("UNKNOWN_StdVideoVP9ColorSpace_value") + std::to_string(value);
+    }
+}
+void DumpStdVideoVP9ColorSpace(Printer &p, std::string name, StdVideoVP9ColorSpace value) {
+    p.PrintKeyString(name, StdVideoVP9ColorSpaceString(value));
+}
+std::string VkColorSpaceKHRString(VkColorSpaceKHR value) {
+    switch (value) {
+        case (VK_COLOR_SPACE_SRGB_NONLINEAR_KHR):
+            return "COLOR_SPACE_SRGB_NONLINEAR_KHR";
+        case (VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT):
+            return "COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT";
+        case (VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT):
+            return "COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT";
+        case (VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT):
+            return "COLOR_SPACE_DISPLAY_P3_LINEAR_EXT";
+        case (VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT):
+            return "COLOR_SPACE_DCI_P3_NONLINEAR_EXT";
+        case (VK_COLOR_SPACE_BT709_LINEAR_EXT):
+            return "COLOR_SPACE_BT709_LINEAR_EXT";
+        case (VK_COLOR_SPACE_BT709_NONLINEAR_EXT):
+            return "COLOR_SPACE_BT709_NONLINEAR_EXT";
+        case (VK_COLOR_SPACE_BT2020_LINEAR_EXT):
+            return "COLOR_SPACE_BT2020_LINEAR_EXT";
+        case (VK_COLOR_SPACE_HDR10_ST2084_EXT):
+            return "COLOR_SPACE_HDR10_ST2084_EXT";
+        case (VK_COLOR_SPACE_DOLBYVISION_EXT):
+            return "COLOR_SPACE_DOLBYVISION_EXT";
+        case (VK_COLOR_SPACE_HDR10_HLG_EXT):
+            return "COLOR_SPACE_HDR10_HLG_EXT";
+        case (VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT):
+            return "COLOR_SPACE_ADOBERGB_LINEAR_EXT";
+        case (VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT):
+            return "COLOR_SPACE_ADOBERGB_NONLINEAR_EXT";
+        case (VK_COLOR_SPACE_PASS_THROUGH_EXT):
+            return "COLOR_SPACE_PASS_THROUGH_EXT";
+        case (VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT):
+            return "COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT";
+        case (VK_COLOR_SPACE_DISPLAY_NATIVE_AMD):
+            return "COLOR_SPACE_DISPLAY_NATIVE_AMD";
+        default:
+            return std::string("UNKNOWN_VkColorSpaceKHR_value") + std::to_string(value);
+    }
+}
+void DumpVkColorSpaceKHR(Printer &p, std::string name, VkColorSpaceKHR value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkColorSpaceKHRString(value));
+    else
+        p.PrintKeyString(name, VkColorSpaceKHRString(value));
+}
+std::string VkComponentSwizzleString(VkComponentSwizzle value) {
+    switch (value) {
+        case (VK_COMPONENT_SWIZZLE_IDENTITY):
+            return "COMPONENT_SWIZZLE_IDENTITY";
+        case (VK_COMPONENT_SWIZZLE_ZERO):
+            return "COMPONENT_SWIZZLE_ZERO";
+        case (VK_COMPONENT_SWIZZLE_ONE):
+            return "COMPONENT_SWIZZLE_ONE";
+        case (VK_COMPONENT_SWIZZLE_R):
+            return "COMPONENT_SWIZZLE_R";
+        case (VK_COMPONENT_SWIZZLE_G):
+            return "COMPONENT_SWIZZLE_G";
+        case (VK_COMPONENT_SWIZZLE_B):
+            return "COMPONENT_SWIZZLE_B";
+        case (VK_COMPONENT_SWIZZLE_A):
+            return "COMPONENT_SWIZZLE_A";
+        default:
+            return std::string("UNKNOWN_VkComponentSwizzle_value") + std::to_string(value);
+    }
+}
+void DumpVkComponentSwizzle(Printer &p, std::string name, VkComponentSwizzle value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkComponentSwizzleString(value));
+    else
+        p.PrintKeyString(name, VkComponentSwizzleString(value));
+}
+std::string VkComponentTypeKHRString(VkComponentTypeKHR value) {
+    switch (value) {
+        case (VK_COMPONENT_TYPE_FLOAT16_KHR):
+            return "COMPONENT_TYPE_FLOAT16_KHR";
+        case (VK_COMPONENT_TYPE_FLOAT32_KHR):
+            return "COMPONENT_TYPE_FLOAT32_KHR";
+        case (VK_COMPONENT_TYPE_FLOAT64_KHR):
+            return "COMPONENT_TYPE_FLOAT64_KHR";
+        case (VK_COMPONENT_TYPE_SINT8_KHR):
+            return "COMPONENT_TYPE_SINT8_KHR";
+        case (VK_COMPONENT_TYPE_SINT16_KHR):
+            return "COMPONENT_TYPE_SINT16_KHR";
+        case (VK_COMPONENT_TYPE_SINT32_KHR):
+            return "COMPONENT_TYPE_SINT32_KHR";
+        case (VK_COMPONENT_TYPE_SINT64_KHR):
+            return "COMPONENT_TYPE_SINT64_KHR";
+        case (VK_COMPONENT_TYPE_UINT8_KHR):
+            return "COMPONENT_TYPE_UINT8_KHR";
+        case (VK_COMPONENT_TYPE_UINT16_KHR):
+            return "COMPONENT_TYPE_UINT16_KHR";
+        case (VK_COMPONENT_TYPE_UINT32_KHR):
+            return "COMPONENT_TYPE_UINT32_KHR";
+        case (VK_COMPONENT_TYPE_UINT64_KHR):
+            return "COMPONENT_TYPE_UINT64_KHR";
+        case (VK_COMPONENT_TYPE_BFLOAT16_KHR):
+            return "COMPONENT_TYPE_BFLOAT16_KHR";
+        case (VK_COMPONENT_TYPE_SINT8_PACKED_NV):
+            return "COMPONENT_TYPE_SINT8_PACKED_NV";
+        case (VK_COMPONENT_TYPE_UINT8_PACKED_NV):
+            return "COMPONENT_TYPE_UINT8_PACKED_NV";
+        case (VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT):
+            return "COMPONENT_TYPE_FLOAT8_E4M3_EXT";
+        case (VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT):
+            return "COMPONENT_TYPE_FLOAT8_E5M2_EXT";
+        default:
+            return std::string("UNKNOWN_VkComponentTypeKHR_value") + std::to_string(value);
+    }
+}
+void DumpVkComponentTypeKHR(Printer &p, std::string name, VkComponentTypeKHR value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkComponentTypeKHRString(value));
+    else
+        p.PrintKeyString(name, VkComponentTypeKHRString(value));
+}
+std::string VkDefaultVertexAttributeValueKHRString(VkDefaultVertexAttributeValueKHR value) {
+    switch (value) {
+        case (VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR):
+            return "DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR";
+        case (VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR):
+            return "DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR";
+        default:
+            return std::string("UNKNOWN_VkDefaultVertexAttributeValueKHR_value") + std::to_string(value);
+    }
+}
+void DumpVkDefaultVertexAttributeValueKHR(Printer &p, std::string name, VkDefaultVertexAttributeValueKHR value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkDefaultVertexAttributeValueKHRString(value));
+    else
+        p.PrintKeyString(name, VkDefaultVertexAttributeValueKHRString(value));
+}
+std::string VkDriverIdString(VkDriverId value) {
+    switch (value) {
+        case (VK_DRIVER_ID_AMD_PROPRIETARY):
+            return "DRIVER_ID_AMD_PROPRIETARY";
+        case (VK_DRIVER_ID_AMD_OPEN_SOURCE):
+            return "DRIVER_ID_AMD_OPEN_SOURCE";
+        case (VK_DRIVER_ID_MESA_RADV):
+            return "DRIVER_ID_MESA_RADV";
+        case (VK_DRIVER_ID_NVIDIA_PROPRIETARY):
+            return "DRIVER_ID_NVIDIA_PROPRIETARY";
+        case (VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS):
+            return "DRIVER_ID_INTEL_PROPRIETARY_WINDOWS";
+        case (VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA):
+            return "DRIVER_ID_INTEL_OPEN_SOURCE_MESA";
+        case (VK_DRIVER_ID_IMAGINATION_PROPRIETARY):
+            return "DRIVER_ID_IMAGINATION_PROPRIETARY";
+        case (VK_DRIVER_ID_QUALCOMM_PROPRIETARY):
+            return "DRIVER_ID_QUALCOMM_PROPRIETARY";
+        case (VK_DRIVER_ID_ARM_PROPRIETARY):
+            return "DRIVER_ID_ARM_PROPRIETARY";
+        case (VK_DRIVER_ID_GOOGLE_SWIFTSHADER):
+            return "DRIVER_ID_GOOGLE_SWIFTSHADER";
+        case (VK_DRIVER_ID_GGP_PROPRIETARY):
+            return "DRIVER_ID_GGP_PROPRIETARY";
+        case (VK_DRIVER_ID_BROADCOM_PROPRIETARY):
+            return "DRIVER_ID_BROADCOM_PROPRIETARY";
+        case (VK_DRIVER_ID_MESA_LLVMPIPE):
+            return "DRIVER_ID_MESA_LLVMPIPE";
+        case (VK_DRIVER_ID_MOLTENVK):
+            return "DRIVER_ID_MOLTENVK";
+        case (VK_DRIVER_ID_COREAVI_PROPRIETARY):
+            return "DRIVER_ID_COREAVI_PROPRIETARY";
+        case (VK_DRIVER_ID_JUICE_PROPRIETARY):
+            return "DRIVER_ID_JUICE_PROPRIETARY";
+        case (VK_DRIVER_ID_VERISILICON_PROPRIETARY):
+            return "DRIVER_ID_VERISILICON_PROPRIETARY";
+        case (VK_DRIVER_ID_MESA_TURNIP):
+            return "DRIVER_ID_MESA_TURNIP";
+        case (VK_DRIVER_ID_MESA_V3DV):
+            return "DRIVER_ID_MESA_V3DV";
+        case (VK_DRIVER_ID_MESA_PANVK):
+            return "DRIVER_ID_MESA_PANVK";
+        case (VK_DRIVER_ID_SAMSUNG_PROPRIETARY):
+            return "DRIVER_ID_SAMSUNG_PROPRIETARY";
+        case (VK_DRIVER_ID_MESA_VENUS):
+            return "DRIVER_ID_MESA_VENUS";
+        case (VK_DRIVER_ID_MESA_DOZEN):
+            return "DRIVER_ID_MESA_DOZEN";
+        case (VK_DRIVER_ID_MESA_NVK):
+            return "DRIVER_ID_MESA_NVK";
+        case (VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA):
+            return "DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA";
+        case (VK_DRIVER_ID_MESA_HONEYKRISP):
+            return "DRIVER_ID_MESA_HONEYKRISP";
+        case (VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN):
+            return "DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN";
+        case (VK_DRIVER_ID_MESA_KOSMICKRISP):
+            return "DRIVER_ID_MESA_KOSMICKRISP";
+        default:
+            return std::string("UNKNOWN_VkDriverId_value") + std::to_string(value);
+    }
+}
+void DumpVkDriverId(Printer &p, std::string name, VkDriverId value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkDriverIdString(value));
+    else
+        p.PrintKeyString(name, VkDriverIdString(value));
+}
+std::string VkFormatString(VkFormat value) {
+    switch (value) {
+        case (VK_FORMAT_UNDEFINED):
+            return "FORMAT_UNDEFINED";
+        case (VK_FORMAT_R4G4_UNORM_PACK8):
+            return "FORMAT_R4G4_UNORM_PACK8";
+        case (VK_FORMAT_R4G4B4A4_UNORM_PACK16):
+            return "FORMAT_R4G4B4A4_UNORM_PACK16";
+        case (VK_FORMAT_B4G4R4A4_UNORM_PACK16):
+            return "FORMAT_B4G4R4A4_UNORM_PACK16";
+        case (VK_FORMAT_R5G6B5_UNORM_PACK16):
+            return "FORMAT_R5G6B5_UNORM_PACK16";
+        case (VK_FORMAT_B5G6R5_UNORM_PACK16):
+            return "FORMAT_B5G6R5_UNORM_PACK16";
+        case (VK_FORMAT_R5G5B5A1_UNORM_PACK16):
+            return "FORMAT_R5G5B5A1_UNORM_PACK16";
+        case (VK_FORMAT_B5G5R5A1_UNORM_PACK16):
+            return "FORMAT_B5G5R5A1_UNORM_PACK16";
+        case (VK_FORMAT_A1R5G5B5_UNORM_PACK16):
+            return "FORMAT_A1R5G5B5_UNORM_PACK16";
+        case (VK_FORMAT_R8_UNORM):
+            return "FORMAT_R8_UNORM";
+        case (VK_FORMAT_R8_SNORM):
+            return "FORMAT_R8_SNORM";
+        case (VK_FORMAT_R8_USCALED):
+            return "FORMAT_R8_USCALED";
+        case (VK_FORMAT_R8_SSCALED):
+            return "FORMAT_R8_SSCALED";
+        case (VK_FORMAT_R8_UINT):
+            return "FORMAT_R8_UINT";
+        case (VK_FORMAT_R8_SINT):
+            return "FORMAT_R8_SINT";
+        case (VK_FORMAT_R8_SRGB):
+            return "FORMAT_R8_SRGB";
+        case (VK_FORMAT_R8G8_UNORM):
+            return "FORMAT_R8G8_UNORM";
+        case (VK_FORMAT_R8G8_SNORM):
+            return "FORMAT_R8G8_SNORM";
+        case (VK_FORMAT_R8G8_USCALED):
+            return "FORMAT_R8G8_USCALED";
+        case (VK_FORMAT_R8G8_SSCALED):
+            return "FORMAT_R8G8_SSCALED";
+        case (VK_FORMAT_R8G8_UINT):
+            return "FORMAT_R8G8_UINT";
+        case (VK_FORMAT_R8G8_SINT):
+            return "FORMAT_R8G8_SINT";
+        case (VK_FORMAT_R8G8_SRGB):
+            return "FORMAT_R8G8_SRGB";
+        case (VK_FORMAT_R8G8B8_UNORM):
+            return "FORMAT_R8G8B8_UNORM";
+        case (VK_FORMAT_R8G8B8_SNORM):
+            return "FORMAT_R8G8B8_SNORM";
+        case (VK_FORMAT_R8G8B8_USCALED):
+            return "FORMAT_R8G8B8_USCALED";
+        case (VK_FORMAT_R8G8B8_SSCALED):
+            return "FORMAT_R8G8B8_SSCALED";
+        case (VK_FORMAT_R8G8B8_UINT):
+            return "FORMAT_R8G8B8_UINT";
+        case (VK_FORMAT_R8G8B8_SINT):
+            return "FORMAT_R8G8B8_SINT";
+        case (VK_FORMAT_R8G8B8_SRGB):
+            return "FORMAT_R8G8B8_SRGB";
+        case (VK_FORMAT_B8G8R8_UNORM):
+            return "FORMAT_B8G8R8_UNORM";
+        case (VK_FORMAT_B8G8R8_SNORM):
+            return "FORMAT_B8G8R8_SNORM";
+        case (VK_FORMAT_B8G8R8_USCALED):
+            return "FORMAT_B8G8R8_USCALED";
+        case (VK_FORMAT_B8G8R8_SSCALED):
+            return "FORMAT_B8G8R8_SSCALED";
+        case (VK_FORMAT_B8G8R8_UINT):
+            return "FORMAT_B8G8R8_UINT";
+        case (VK_FORMAT_B8G8R8_SINT):
+            return "FORMAT_B8G8R8_SINT";
+        case (VK_FORMAT_B8G8R8_SRGB):
+            return "FORMAT_B8G8R8_SRGB";
+        case (VK_FORMAT_R8G8B8A8_UNORM):
+            return "FORMAT_R8G8B8A8_UNORM";
+        case (VK_FORMAT_R8G8B8A8_SNORM):
+            return "FORMAT_R8G8B8A8_SNORM";
+        case (VK_FORMAT_R8G8B8A8_USCALED):
+            return "FORMAT_R8G8B8A8_USCALED";
+        case (VK_FORMAT_R8G8B8A8_SSCALED):
+            return "FORMAT_R8G8B8A8_SSCALED";
+        case (VK_FORMAT_R8G8B8A8_UINT):
+            return "FORMAT_R8G8B8A8_UINT";
+        case (VK_FORMAT_R8G8B8A8_SINT):
+            return "FORMAT_R8G8B8A8_SINT";
+        case (VK_FORMAT_R8G8B8A8_SRGB):
+            return "FORMAT_R8G8B8A8_SRGB";
+        case (VK_FORMAT_B8G8R8A8_UNORM):
+            return "FORMAT_B8G8R8A8_UNORM";
+        case (VK_FORMAT_B8G8R8A8_SNORM):
+            return "FORMAT_B8G8R8A8_SNORM";
+        case (VK_FORMAT_B8G8R8A8_USCALED):
+            return "FORMAT_B8G8R8A8_USCALED";
+        case (VK_FORMAT_B8G8R8A8_SSCALED):
+            return "FORMAT_B8G8R8A8_SSCALED";
+        case (VK_FORMAT_B8G8R8A8_UINT):
+            return "FORMAT_B8G8R8A8_UINT";
+        case (VK_FORMAT_B8G8R8A8_SINT):
+            return "FORMAT_B8G8R8A8_SINT";
+        case (VK_FORMAT_B8G8R8A8_SRGB):
+            return "FORMAT_B8G8R8A8_SRGB";
+        case (VK_FORMAT_A8B8G8R8_UNORM_PACK32):
+            return "FORMAT_A8B8G8R8_UNORM_PACK32";
+        case (VK_FORMAT_A8B8G8R8_SNORM_PACK32):
+            return "FORMAT_A8B8G8R8_SNORM_PACK32";
+        case (VK_FORMAT_A8B8G8R8_USCALED_PACK32):
+            return "FORMAT_A8B8G8R8_USCALED_PACK32";
+        case (VK_FORMAT_A8B8G8R8_SSCALED_PACK32):
+            return "FORMAT_A8B8G8R8_SSCALED_PACK32";
+        case (VK_FORMAT_A8B8G8R8_UINT_PACK32):
+            return "FORMAT_A8B8G8R8_UINT_PACK32";
+        case (VK_FORMAT_A8B8G8R8_SINT_PACK32):
+            return "FORMAT_A8B8G8R8_SINT_PACK32";
+        case (VK_FORMAT_A8B8G8R8_SRGB_PACK32):
+            return "FORMAT_A8B8G8R8_SRGB_PACK32";
+        case (VK_FORMAT_A2R10G10B10_UNORM_PACK32):
+            return "FORMAT_A2R10G10B10_UNORM_PACK32";
+        case (VK_FORMAT_A2R10G10B10_SNORM_PACK32):
+            return "FORMAT_A2R10G10B10_SNORM_PACK32";
+        case (VK_FORMAT_A2R10G10B10_USCALED_PACK32):
+            return "FORMAT_A2R10G10B10_USCALED_PACK32";
+        case (VK_FORMAT_A2R10G10B10_SSCALED_PACK32):
+            return "FORMAT_A2R10G10B10_SSCALED_PACK32";
+        case (VK_FORMAT_A2R10G10B10_UINT_PACK32):
+            return "FORMAT_A2R10G10B10_UINT_PACK32";
+        case (VK_FORMAT_A2R10G10B10_SINT_PACK32):
+            return "FORMAT_A2R10G10B10_SINT_PACK32";
+        case (VK_FORMAT_A2B10G10R10_UNORM_PACK32):
+            return "FORMAT_A2B10G10R10_UNORM_PACK32";
+        case (VK_FORMAT_A2B10G10R10_SNORM_PACK32):
+            return "FORMAT_A2B10G10R10_SNORM_PACK32";
+        case (VK_FORMAT_A2B10G10R10_USCALED_PACK32):
+            return "FORMAT_A2B10G10R10_USCALED_PACK32";
+        case (VK_FORMAT_A2B10G10R10_SSCALED_PACK32):
+            return "FORMAT_A2B10G10R10_SSCALED_PACK32";
+        case (VK_FORMAT_A2B10G10R10_UINT_PACK32):
+            return "FORMAT_A2B10G10R10_UINT_PACK32";
+        case (VK_FORMAT_A2B10G10R10_SINT_PACK32):
+            return "FORMAT_A2B10G10R10_SINT_PACK32";
+        case (VK_FORMAT_R16_UNORM):
+            return "FORMAT_R16_UNORM";
+        case (VK_FORMAT_R16_SNORM):
+            return "FORMAT_R16_SNORM";
+        case (VK_FORMAT_R16_USCALED):
+            return "FORMAT_R16_USCALED";
+        case (VK_FORMAT_R16_SSCALED):
+            return "FORMAT_R16_SSCALED";
+        case (VK_FORMAT_R16_UINT):
+            return "FORMAT_R16_UINT";
+        case (VK_FORMAT_R16_SINT):
+            return "FORMAT_R16_SINT";
+        case (VK_FORMAT_R16_SFLOAT):
+            return "FORMAT_R16_SFLOAT";
+        case (VK_FORMAT_R16G16_UNORM):
+            return "FORMAT_R16G16_UNORM";
+        case (VK_FORMAT_R16G16_SNORM):
+            return "FORMAT_R16G16_SNORM";
+        case (VK_FORMAT_R16G16_USCALED):
+            return "FORMAT_R16G16_USCALED";
+        case (VK_FORMAT_R16G16_SSCALED):
+            return "FORMAT_R16G16_SSCALED";
+        case (VK_FORMAT_R16G16_UINT):
+            return "FORMAT_R16G16_UINT";
+        case (VK_FORMAT_R16G16_SINT):
+            return "FORMAT_R16G16_SINT";
+        case (VK_FORMAT_R16G16_SFLOAT):
+            return "FORMAT_R16G16_SFLOAT";
+        case (VK_FORMAT_R16G16B16_UNORM):
+            return "FORMAT_R16G16B16_UNORM";
+        case (VK_FORMAT_R16G16B16_SNORM):
+            return "FORMAT_R16G16B16_SNORM";
+        case (VK_FORMAT_R16G16B16_USCALED):
+            return "FORMAT_R16G16B16_USCALED";
+        case (VK_FORMAT_R16G16B16_SSCALED):
+            return "FORMAT_R16G16B16_SSCALED";
+        case (VK_FORMAT_R16G16B16_UINT):
+            return "FORMAT_R16G16B16_UINT";
+        case (VK_FORMAT_R16G16B16_SINT):
+            return "FORMAT_R16G16B16_SINT";
+        case (VK_FORMAT_R16G16B16_SFLOAT):
+            return "FORMAT_R16G16B16_SFLOAT";
+        case (VK_FORMAT_R16G16B16A16_UNORM):
+            return "FORMAT_R16G16B16A16_UNORM";
+        case (VK_FORMAT_R16G16B16A16_SNORM):
+            return "FORMAT_R16G16B16A16_SNORM";
+        case (VK_FORMAT_R16G16B16A16_USCALED):
+            return "FORMAT_R16G16B16A16_USCALED";
+        case (VK_FORMAT_R16G16B16A16_SSCALED):
+            return "FORMAT_R16G16B16A16_SSCALED";
+        case (VK_FORMAT_R16G16B16A16_UINT):
+            return "FORMAT_R16G16B16A16_UINT";
+        case (VK_FORMAT_R16G16B16A16_SINT):
+            return "FORMAT_R16G16B16A16_SINT";
+        case (VK_FORMAT_R16G16B16A16_SFLOAT):
+            return "FORMAT_R16G16B16A16_SFLOAT";
+        case (VK_FORMAT_R32_UINT):
+            return "FORMAT_R32_UINT";
+        case (VK_FORMAT_R32_SINT):
+            return "FORMAT_R32_SINT";
+        case (VK_FORMAT_R32_SFLOAT):
+            return "FORMAT_R32_SFLOAT";
+        case (VK_FORMAT_R32G32_UINT):
+            return "FORMAT_R32G32_UINT";
+        case (VK_FORMAT_R32G32_SINT):
+            return "FORMAT_R32G32_SINT";
+        case (VK_FORMAT_R32G32_SFLOAT):
+            return "FORMAT_R32G32_SFLOAT";
+        case (VK_FORMAT_R32G32B32_UINT):
+            return "FORMAT_R32G32B32_UINT";
+        case (VK_FORMAT_R32G32B32_SINT):
+            return "FORMAT_R32G32B32_SINT";
+        case (VK_FORMAT_R32G32B32_SFLOAT):
+            return "FORMAT_R32G32B32_SFLOAT";
+        case (VK_FORMAT_R32G32B32A32_UINT):
+            return "FORMAT_R32G32B32A32_UINT";
+        case (VK_FORMAT_R32G32B32A32_SINT):
+            return "FORMAT_R32G32B32A32_SINT";
+        case (VK_FORMAT_R32G32B32A32_SFLOAT):
+            return "FORMAT_R32G32B32A32_SFLOAT";
+        case (VK_FORMAT_R64_UINT):
+            return "FORMAT_R64_UINT";
+        case (VK_FORMAT_R64_SINT):
+            return "FORMAT_R64_SINT";
+        case (VK_FORMAT_R64_SFLOAT):
+            return "FORMAT_R64_SFLOAT";
+        case (VK_FORMAT_R64G64_UINT):
+            return "FORMAT_R64G64_UINT";
+        case (VK_FORMAT_R64G64_SINT):
+            return "FORMAT_R64G64_SINT";
+        case (VK_FORMAT_R64G64_SFLOAT):
+            return "FORMAT_R64G64_SFLOAT";
+        case (VK_FORMAT_R64G64B64_UINT):
+            return "FORMAT_R64G64B64_UINT";
+        case (VK_FORMAT_R64G64B64_SINT):
+            return "FORMAT_R64G64B64_SINT";
+        case (VK_FORMAT_R64G64B64_SFLOAT):
+            return "FORMAT_R64G64B64_SFLOAT";
+        case (VK_FORMAT_R64G64B64A64_UINT):
+            return "FORMAT_R64G64B64A64_UINT";
+        case (VK_FORMAT_R64G64B64A64_SINT):
+            return "FORMAT_R64G64B64A64_SINT";
+        case (VK_FORMAT_R64G64B64A64_SFLOAT):
+            return "FORMAT_R64G64B64A64_SFLOAT";
+        case (VK_FORMAT_B10G11R11_UFLOAT_PACK32):
+            return "FORMAT_B10G11R11_UFLOAT_PACK32";
+        case (VK_FORMAT_E5B9G9R9_UFLOAT_PACK32):
+            return "FORMAT_E5B9G9R9_UFLOAT_PACK32";
+        case (VK_FORMAT_D16_UNORM):
+            return "FORMAT_D16_UNORM";
+        case (VK_FORMAT_X8_D24_UNORM_PACK32):
+            return "FORMAT_X8_D24_UNORM_PACK32";
+        case (VK_FORMAT_D32_SFLOAT):
+            return "FORMAT_D32_SFLOAT";
+        case (VK_FORMAT_S8_UINT):
+            return "FORMAT_S8_UINT";
+        case (VK_FORMAT_D16_UNORM_S8_UINT):
+            return "FORMAT_D16_UNORM_S8_UINT";
+        case (VK_FORMAT_D24_UNORM_S8_UINT):
+            return "FORMAT_D24_UNORM_S8_UINT";
+        case (VK_FORMAT_D32_SFLOAT_S8_UINT):
+            return "FORMAT_D32_SFLOAT_S8_UINT";
+        case (VK_FORMAT_BC1_RGB_UNORM_BLOCK):
+            return "FORMAT_BC1_RGB_UNORM_BLOCK";
+        case (VK_FORMAT_BC1_RGB_SRGB_BLOCK):
+            return "FORMAT_BC1_RGB_SRGB_BLOCK";
+        case (VK_FORMAT_BC1_RGBA_UNORM_BLOCK):
+            return "FORMAT_BC1_RGBA_UNORM_BLOCK";
+        case (VK_FORMAT_BC1_RGBA_SRGB_BLOCK):
+            return "FORMAT_BC1_RGBA_SRGB_BLOCK";
+        case (VK_FORMAT_BC2_UNORM_BLOCK):
+            return "FORMAT_BC2_UNORM_BLOCK";
+        case (VK_FORMAT_BC2_SRGB_BLOCK):
+            return "FORMAT_BC2_SRGB_BLOCK";
+        case (VK_FORMAT_BC3_UNORM_BLOCK):
+            return "FORMAT_BC3_UNORM_BLOCK";
+        case (VK_FORMAT_BC3_SRGB_BLOCK):
+            return "FORMAT_BC3_SRGB_BLOCK";
+        case (VK_FORMAT_BC4_UNORM_BLOCK):
+            return "FORMAT_BC4_UNORM_BLOCK";
+        case (VK_FORMAT_BC4_SNORM_BLOCK):
+            return "FORMAT_BC4_SNORM_BLOCK";
+        case (VK_FORMAT_BC5_UNORM_BLOCK):
+            return "FORMAT_BC5_UNORM_BLOCK";
+        case (VK_FORMAT_BC5_SNORM_BLOCK):
+            return "FORMAT_BC5_SNORM_BLOCK";
+        case (VK_FORMAT_BC6H_UFLOAT_BLOCK):
+            return "FORMAT_BC6H_UFLOAT_BLOCK";
+        case (VK_FORMAT_BC6H_SFLOAT_BLOCK):
+            return "FORMAT_BC6H_SFLOAT_BLOCK";
+        case (VK_FORMAT_BC7_UNORM_BLOCK):
+            return "FORMAT_BC7_UNORM_BLOCK";
+        case (VK_FORMAT_BC7_SRGB_BLOCK):
+            return "FORMAT_BC7_SRGB_BLOCK";
+        case (VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK):
+            return "FORMAT_ETC2_R8G8B8_UNORM_BLOCK";
+        case (VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK):
+            return "FORMAT_ETC2_R8G8B8_SRGB_BLOCK";
+        case (VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK):
+            return "FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK";
+        case (VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK):
+            return "FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK";
+        case (VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK):
+            return "FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK";
+        case (VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK):
+            return "FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK";
+        case (VK_FORMAT_EAC_R11_UNORM_BLOCK):
+            return "FORMAT_EAC_R11_UNORM_BLOCK";
+        case (VK_FORMAT_EAC_R11_SNORM_BLOCK):
+            return "FORMAT_EAC_R11_SNORM_BLOCK";
+        case (VK_FORMAT_EAC_R11G11_UNORM_BLOCK):
+            return "FORMAT_EAC_R11G11_UNORM_BLOCK";
+        case (VK_FORMAT_EAC_R11G11_SNORM_BLOCK):
+            return "FORMAT_EAC_R11G11_SNORM_BLOCK";
+        case (VK_FORMAT_ASTC_4x4_UNORM_BLOCK):
+            return "FORMAT_ASTC_4x4_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_4x4_SRGB_BLOCK):
+            return "FORMAT_ASTC_4x4_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_5x4_UNORM_BLOCK):
+            return "FORMAT_ASTC_5x4_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_5x4_SRGB_BLOCK):
+            return "FORMAT_ASTC_5x4_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_5x5_UNORM_BLOCK):
+            return "FORMAT_ASTC_5x5_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_5x5_SRGB_BLOCK):
+            return "FORMAT_ASTC_5x5_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_6x5_UNORM_BLOCK):
+            return "FORMAT_ASTC_6x5_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_6x5_SRGB_BLOCK):
+            return "FORMAT_ASTC_6x5_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_6x6_UNORM_BLOCK):
+            return "FORMAT_ASTC_6x6_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_6x6_SRGB_BLOCK):
+            return "FORMAT_ASTC_6x6_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_8x5_UNORM_BLOCK):
+            return "FORMAT_ASTC_8x5_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_8x5_SRGB_BLOCK):
+            return "FORMAT_ASTC_8x5_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_8x6_UNORM_BLOCK):
+            return "FORMAT_ASTC_8x6_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_8x6_SRGB_BLOCK):
+            return "FORMAT_ASTC_8x6_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_8x8_UNORM_BLOCK):
+            return "FORMAT_ASTC_8x8_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_8x8_SRGB_BLOCK):
+            return "FORMAT_ASTC_8x8_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_10x5_UNORM_BLOCK):
+            return "FORMAT_ASTC_10x5_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_10x5_SRGB_BLOCK):
+            return "FORMAT_ASTC_10x5_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_10x6_UNORM_BLOCK):
+            return "FORMAT_ASTC_10x6_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_10x6_SRGB_BLOCK):
+            return "FORMAT_ASTC_10x6_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_10x8_UNORM_BLOCK):
+            return "FORMAT_ASTC_10x8_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_10x8_SRGB_BLOCK):
+            return "FORMAT_ASTC_10x8_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_10x10_UNORM_BLOCK):
+            return "FORMAT_ASTC_10x10_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_10x10_SRGB_BLOCK):
+            return "FORMAT_ASTC_10x10_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_12x10_UNORM_BLOCK):
+            return "FORMAT_ASTC_12x10_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_12x10_SRGB_BLOCK):
+            return "FORMAT_ASTC_12x10_SRGB_BLOCK";
+        case (VK_FORMAT_ASTC_12x12_UNORM_BLOCK):
+            return "FORMAT_ASTC_12x12_UNORM_BLOCK";
+        case (VK_FORMAT_ASTC_12x12_SRGB_BLOCK):
+            return "FORMAT_ASTC_12x12_SRGB_BLOCK";
+        case (VK_FORMAT_G8B8G8R8_422_UNORM):
+            return "FORMAT_G8B8G8R8_422_UNORM";
+        case (VK_FORMAT_B8G8R8G8_422_UNORM):
+            return "FORMAT_B8G8R8G8_422_UNORM";
+        case (VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM):
+            return "FORMAT_G8_B8_R8_3PLANE_420_UNORM";
+        case (VK_FORMAT_G8_B8R8_2PLANE_420_UNORM):
+            return "FORMAT_G8_B8R8_2PLANE_420_UNORM";
+        case (VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM):
+            return "FORMAT_G8_B8_R8_3PLANE_422_UNORM";
+        case (VK_FORMAT_G8_B8R8_2PLANE_422_UNORM):
+            return "FORMAT_G8_B8R8_2PLANE_422_UNORM";
+        case (VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM):
+            return "FORMAT_G8_B8_R8_3PLANE_444_UNORM";
+        case (VK_FORMAT_R10X6_UNORM_PACK16):
+            return "FORMAT_R10X6_UNORM_PACK16";
+        case (VK_FORMAT_R10X6G10X6_UNORM_2PACK16):
+            return "FORMAT_R10X6G10X6_UNORM_2PACK16";
+        case (VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16):
+            return "FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16";
+        case (VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16):
+            return "FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16";
+        case (VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16):
+            return "FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16";
+        case (VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16):
+            return "FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16";
+        case (VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16):
+            return "FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16";
+        case (VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16):
+            return "FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16";
+        case (VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16):
+            return "FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16";
+        case (VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16):
+            return "FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16";
+        case (VK_FORMAT_R12X4_UNORM_PACK16):
+            return "FORMAT_R12X4_UNORM_PACK16";
+        case (VK_FORMAT_R12X4G12X4_UNORM_2PACK16):
+            return "FORMAT_R12X4G12X4_UNORM_2PACK16";
+        case (VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16):
+            return "FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16";
+        case (VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16):
+            return "FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16";
+        case (VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16):
+            return "FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16";
+        case (VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16):
+            return "FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16";
+        case (VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16):
+            return "FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16";
+        case (VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16):
+            return "FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16";
+        case (VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16):
+            return "FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16";
+        case (VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16):
+            return "FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16";
+        case (VK_FORMAT_G16B16G16R16_422_UNORM):
+            return "FORMAT_G16B16G16R16_422_UNORM";
+        case (VK_FORMAT_B16G16R16G16_422_UNORM):
+            return "FORMAT_B16G16R16G16_422_UNORM";
+        case (VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM):
+            return "FORMAT_G16_B16_R16_3PLANE_420_UNORM";
+        case (VK_FORMAT_G16_B16R16_2PLANE_420_UNORM):
+            return "FORMAT_G16_B16R16_2PLANE_420_UNORM";
+        case (VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM):
+            return "FORMAT_G16_B16_R16_3PLANE_422_UNORM";
+        case (VK_FORMAT_G16_B16R16_2PLANE_422_UNORM):
+            return "FORMAT_G16_B16R16_2PLANE_422_UNORM";
+        case (VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM):
+            return "FORMAT_G16_B16_R16_3PLANE_444_UNORM";
+        case (VK_FORMAT_G8_B8R8_2PLANE_444_UNORM):
+            return "FORMAT_G8_B8R8_2PLANE_444_UNORM";
+        case (VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16):
+            return "FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16";
+        case (VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16):
+            return "FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16";
+        case (VK_FORMAT_G16_B16R16_2PLANE_444_UNORM):
+            return "FORMAT_G16_B16R16_2PLANE_444_UNORM";
+        case (VK_FORMAT_A4R4G4B4_UNORM_PACK16):
+            return "FORMAT_A4R4G4B4_UNORM_PACK16";
+        case (VK_FORMAT_A4B4G4R4_UNORM_PACK16):
+            return "FORMAT_A4B4G4R4_UNORM_PACK16";
+        case (VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_4x4_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_5x4_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_5x5_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_6x5_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_6x6_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_8x5_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_8x6_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_8x8_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_10x5_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_10x6_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_10x8_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_10x10_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_12x10_SFLOAT_BLOCK";
+        case (VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK):
+            return "FORMAT_ASTC_12x12_SFLOAT_BLOCK";
+        case (VK_FORMAT_A1B5G5R5_UNORM_PACK16):
+            return "FORMAT_A1B5G5R5_UNORM_PACK16";
+        case (VK_FORMAT_A8_UNORM):
+            return "FORMAT_A8_UNORM";
+        case (VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG):
+            return "FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG";
+        case (VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG):
+            return "FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG";
+        case (VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG):
+            return "FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG";
+        case (VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG):
+            return "FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG";
+        case (VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG):
+            return "FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG";
+        case (VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG):
+            return "FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG";
+        case (VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG):
+            return "FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG";
+        case (VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG):
+            return "FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG";
+        case (VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT):
+            return "FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT):
+            return "FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT):
+            return "FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT):
+            return "FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT):
+            return "FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT):
+            return "FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT):
+            return "FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT):
+            return "FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT):
+            return "FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT):
+            return "FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT):
+            return "FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT):
+            return "FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT):
+            return "FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT):
+            return "FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT):
+            return "FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT):
+            return "FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT):
+            return "FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT):
+            return "FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT):
+            return "FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT):
+            return "FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT):
+            return "FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT):
+            return "FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT):
+            return "FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT):
+            return "FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT):
+            return "FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT):
+            return "FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT):
+            return "FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT):
+            return "FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT):
+            return "FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT";
+        case (VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT):
+            return "FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT";
+        case (VK_FORMAT_R8_BOOL_ARM):
+            return "FORMAT_R8_BOOL_ARM";
+        case (VK_FORMAT_R16_SFLOAT_FPENCODING_BFLOAT16_ARM):
+            return "FORMAT_R16_SFLOAT_FPENCODING_BFLOAT16_ARM";
+        case (VK_FORMAT_R8_SFLOAT_FPENCODING_FLOAT8E4M3_ARM):
+            return "FORMAT_R8_SFLOAT_FPENCODING_FLOAT8E4M3_ARM";
+        case (VK_FORMAT_R8_SFLOAT_FPENCODING_FLOAT8E5M2_ARM):
+            return "FORMAT_R8_SFLOAT_FPENCODING_FLOAT8E5M2_ARM";
+        case (VK_FORMAT_R16G16_SFIXED5_NV):
+            return "FORMAT_R16G16_SFIXED5_NV";
+        case (VK_FORMAT_R10X6_UINT_PACK16_ARM):
+            return "FORMAT_R10X6_UINT_PACK16_ARM";
+        case (VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM):
+            return "FORMAT_R10X6G10X6_UINT_2PACK16_ARM";
+        case (VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM):
+            return "FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM";
+        case (VK_FORMAT_R12X4_UINT_PACK16_ARM):
+            return "FORMAT_R12X4_UINT_PACK16_ARM";
+        case (VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM):
+            return "FORMAT_R12X4G12X4_UINT_2PACK16_ARM";
+        case (VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM):
+            return "FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM";
+        case (VK_FORMAT_R14X2_UINT_PACK16_ARM):
+            return "FORMAT_R14X2_UINT_PACK16_ARM";
+        case (VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM):
+            return "FORMAT_R14X2G14X2_UINT_2PACK16_ARM";
+        case (VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM):
+            return "FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM";
+        case (VK_FORMAT_R14X2_UNORM_PACK16_ARM):
+            return "FORMAT_R14X2_UNORM_PACK16_ARM";
+        case (VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM):
+            return "FORMAT_R14X2G14X2_UNORM_2PACK16_ARM";
+        case (VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM):
+            return "FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM";
+        case (VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM):
+            return "FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM";
+        case (VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM):
+            return "FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM";
+        default:
+            return std::string("UNKNOWN_VkFormat_value") + std::to_string(value);
+    }
+}
+void DumpVkFormat(Printer &p, std::string name, VkFormat value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkFormatString(value));
+    else
+        p.PrintKeyString(name, VkFormatString(value));
+}
+std::string VkImageLayoutString(VkImageLayout value) {
+    switch (value) {
+        case (VK_IMAGE_LAYOUT_UNDEFINED):
+            return "IMAGE_LAYOUT_UNDEFINED";
+        case (VK_IMAGE_LAYOUT_GENERAL):
+            return "IMAGE_LAYOUT_GENERAL";
+        case (VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL):
+            return "IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL):
+            return "IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL):
+            return "IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL):
+            return "IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL):
+            return "IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL):
+            return "IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_PREINITIALIZED):
+            return "IMAGE_LAYOUT_PREINITIALIZED";
+        case (VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL):
+            return "IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL):
+            return "IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL):
+            return "IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL):
+            return "IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL):
+            return "IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL):
+            return "IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL):
+            return "IMAGE_LAYOUT_READ_ONLY_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL):
+            return "IMAGE_LAYOUT_ATTACHMENT_OPTIMAL";
+        case (VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ):
+            return "IMAGE_LAYOUT_RENDERING_LOCAL_READ";
+        case (VK_IMAGE_LAYOUT_PRESENT_SRC_KHR):
+            return "IMAGE_LAYOUT_PRESENT_SRC_KHR";
+        case (VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR):
+            return "IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR";
+        case (VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR):
+            return "IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR";
+        case (VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR):
+            return "IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR";
+        case (VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR):
+            return "IMAGE_LAYOUT_SHARED_PRESENT_KHR";
+        case (VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT):
+            return "IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT";
+        case (VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR):
+            return "IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR";
+        case (VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR):
+            return "IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR";
+        case (VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR):
+            return "IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR";
+        case (VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR):
+            return "IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR";
+        case (VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT):
+            return "IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT";
+        case (VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM):
+            return "IMAGE_LAYOUT_TENSOR_ALIASING_ARM";
+        case (VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR):
+            return "IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR";
+        case (VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT):
+            return "IMAGE_LAYOUT_ZERO_INITIALIZED_EXT";
+        default:
+            return std::string("UNKNOWN_VkImageLayout_value") + std::to_string(value);
+    }
+}
+void DumpVkImageLayout(Printer &p, std::string name, VkImageLayout value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkImageLayoutString(value));
+    else
+        p.PrintKeyString(name, VkImageLayoutString(value));
+}
+std::string VkImageTilingString(VkImageTiling value) {
+    switch (value) {
+        case (VK_IMAGE_TILING_OPTIMAL):
+            return "IMAGE_TILING_OPTIMAL";
+        case (VK_IMAGE_TILING_LINEAR):
+            return "IMAGE_TILING_LINEAR";
+        case (VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT):
+            return "IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT";
+        default:
+            return std::string("UNKNOWN_VkImageTiling_value") + std::to_string(value);
+    }
+}
+void DumpVkImageTiling(Printer &p, std::string name, VkImageTiling value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkImageTilingString(value));
+    else
+        p.PrintKeyString(name, VkImageTilingString(value));
+}
+std::string VkImageTypeString(VkImageType value) {
+    switch (value) {
+        case (VK_IMAGE_TYPE_1D):
+            return "IMAGE_TYPE_1D";
+        case (VK_IMAGE_TYPE_2D):
+            return "IMAGE_TYPE_2D";
+        case (VK_IMAGE_TYPE_3D):
+            return "IMAGE_TYPE_3D";
+        default:
+            return std::string("UNKNOWN_VkImageType_value") + std::to_string(value);
+    }
+}
+void DumpVkImageType(Printer &p, std::string name, VkImageType value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkImageTypeString(value));
+    else
+        p.PrintKeyString(name, VkImageTypeString(value));
+}
+std::string VkPhysicalDeviceLayeredApiKHRString(VkPhysicalDeviceLayeredApiKHR value) {
+    switch (value) {
+        case (VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR):
+            return "PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR";
+        case (VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR):
+            return "PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR";
+        case (VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR):
+            return "PHYSICAL_DEVICE_LAYERED_API_METAL_KHR";
+        case (VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR):
+            return "PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR";
+        case (VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR):
+            return "PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR";
+        default:
+            return std::string("UNKNOWN_VkPhysicalDeviceLayeredApiKHR_value") + std::to_string(value);
+    }
+}
+void DumpVkPhysicalDeviceLayeredApiKHR(Printer &p, std::string name, VkPhysicalDeviceLayeredApiKHR value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkPhysicalDeviceLayeredApiKHRString(value));
+    else
+        p.PrintKeyString(name, VkPhysicalDeviceLayeredApiKHRString(value));
+}
+std::string VkPhysicalDeviceTypeString(VkPhysicalDeviceType value) {
+    switch (value) {
+        case (VK_PHYSICAL_DEVICE_TYPE_OTHER):
+            return "PHYSICAL_DEVICE_TYPE_OTHER";
+        case (VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU):
+            return "PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU";
+        case (VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU):
+            return "PHYSICAL_DEVICE_TYPE_DISCRETE_GPU";
+        case (VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU):
+            return "PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU";
+        case (VK_PHYSICAL_DEVICE_TYPE_CPU):
+            return "PHYSICAL_DEVICE_TYPE_CPU";
+        default:
+            return std::string("UNKNOWN_VkPhysicalDeviceType_value") + std::to_string(value);
+    }
+}
+void DumpVkPhysicalDeviceType(Printer &p, std::string name, VkPhysicalDeviceType value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkPhysicalDeviceTypeString(value));
+    else
+        p.PrintKeyString(name, VkPhysicalDeviceTypeString(value));
+}
+std::string VkPipelineRobustnessBufferBehaviorString(VkPipelineRobustnessBufferBehavior value) {
+    switch (value) {
+        case (VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT):
+            return "PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT";
+        case (VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED):
+            return "PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED";
+        case (VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS):
+            return "PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS";
+        case (VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2):
+            return "PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2";
+        default:
+            return std::string("UNKNOWN_VkPipelineRobustnessBufferBehavior_value") + std::to_string(value);
+    }
+}
+void DumpVkPipelineRobustnessBufferBehavior(Printer &p, std::string name, VkPipelineRobustnessBufferBehavior value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkPipelineRobustnessBufferBehaviorString(value));
+    else
+        p.PrintKeyString(name, VkPipelineRobustnessBufferBehaviorString(value));
+}
+std::string VkPipelineRobustnessImageBehaviorString(VkPipelineRobustnessImageBehavior value) {
+    switch (value) {
+        case (VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT):
+            return "PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT";
+        case (VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED):
+            return "PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED";
+        case (VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS):
+            return "PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS";
+        case (VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2):
+            return "PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2";
+        default:
+            return std::string("UNKNOWN_VkPipelineRobustnessImageBehavior_value") + std::to_string(value);
+    }
+}
+void DumpVkPipelineRobustnessImageBehavior(Printer &p, std::string name, VkPipelineRobustnessImageBehavior value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkPipelineRobustnessImageBehaviorString(value));
+    else
+        p.PrintKeyString(name, VkPipelineRobustnessImageBehaviorString(value));
+}
+std::string VkPointClippingBehaviorString(VkPointClippingBehavior value) {
+    switch (value) {
+        case (VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES):
+            return "POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES";
+        case (VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY):
+            return "POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY";
+        default:
+            return std::string("UNKNOWN_VkPointClippingBehavior_value") + std::to_string(value);
+    }
+}
+void DumpVkPointClippingBehavior(Printer &p, std::string name, VkPointClippingBehavior value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkPointClippingBehaviorString(value));
+    else
+        p.PrintKeyString(name, VkPointClippingBehaviorString(value));
+}
+std::string VkPresentModeKHRString(VkPresentModeKHR value) {
+    switch (value) {
+        case (VK_PRESENT_MODE_IMMEDIATE_KHR):
+            return "PRESENT_MODE_IMMEDIATE_KHR";
+        case (VK_PRESENT_MODE_MAILBOX_KHR):
+            return "PRESENT_MODE_MAILBOX_KHR";
+        case (VK_PRESENT_MODE_FIFO_KHR):
+            return "PRESENT_MODE_FIFO_KHR";
+        case (VK_PRESENT_MODE_FIFO_RELAXED_KHR):
+            return "PRESENT_MODE_FIFO_RELAXED_KHR";
+        case (VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR):
+            return "PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR";
+        case (VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR):
+            return "PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR";
+        case (VK_PRESENT_MODE_FIFO_LATEST_READY_KHR):
+            return "PRESENT_MODE_FIFO_LATEST_READY_KHR";
+        default:
+            return std::string("UNKNOWN_VkPresentModeKHR_value") + std::to_string(value);
+    }
+}
+void DumpVkPresentModeKHR(Printer &p, std::string name, VkPresentModeKHR value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkPresentModeKHRString(value));
+    else
+        p.PrintKeyString(name, VkPresentModeKHRString(value));
+}
+std::string VkQueueGlobalPriorityString(VkQueueGlobalPriority value) {
+    switch (value) {
+        case (VK_QUEUE_GLOBAL_PRIORITY_LOW):
+            return "QUEUE_GLOBAL_PRIORITY_LOW";
+        case (VK_QUEUE_GLOBAL_PRIORITY_MEDIUM):
+            return "QUEUE_GLOBAL_PRIORITY_MEDIUM";
+        case (VK_QUEUE_GLOBAL_PRIORITY_HIGH):
+            return "QUEUE_GLOBAL_PRIORITY_HIGH";
+        case (VK_QUEUE_GLOBAL_PRIORITY_REALTIME):
+            return "QUEUE_GLOBAL_PRIORITY_REALTIME";
+        default:
+            return std::string("UNKNOWN_VkQueueGlobalPriority_value") + std::to_string(value);
+    }
+}
+void DumpVkQueueGlobalPriority(Printer &p, std::string name, VkQueueGlobalPriority value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkQueueGlobalPriorityString(value));
+    else
+        p.PrintKeyString(name, VkQueueGlobalPriorityString(value));
+}
+std::string VkRayTracingInvocationReorderModeEXTString(VkRayTracingInvocationReorderModeEXT value) {
+    switch (value) {
+        case (VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT):
+            return "RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT";
+        case (VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT):
+            return "RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT";
+        default:
+            return std::string("UNKNOWN_VkRayTracingInvocationReorderModeEXT_value") + std::to_string(value);
+    }
+}
+void DumpVkRayTracingInvocationReorderModeEXT(Printer &p, std::string name, VkRayTracingInvocationReorderModeEXT value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkRayTracingInvocationReorderModeEXTString(value));
+    else
+        p.PrintKeyString(name, VkRayTracingInvocationReorderModeEXTString(value));
+}
+std::string VkResultString(VkResult value) {
+    switch (value) {
+        case (VK_SUCCESS):
+            return "SUCCESS";
+        case (VK_NOT_READY):
+            return "NOT_READY";
+        case (VK_TIMEOUT):
+            return "TIMEOUT";
+        case (VK_EVENT_SET):
+            return "EVENT_SET";
+        case (VK_EVENT_RESET):
+            return "EVENT_RESET";
+        case (VK_INCOMPLETE):
+            return "INCOMPLETE";
+        case (VK_ERROR_OUT_OF_HOST_MEMORY):
+            return "ERROR_OUT_OF_HOST_MEMORY";
+        case (VK_ERROR_OUT_OF_DEVICE_MEMORY):
+            return "ERROR_OUT_OF_DEVICE_MEMORY";
+        case (VK_ERROR_INITIALIZATION_FAILED):
+            return "ERROR_INITIALIZATION_FAILED";
+        case (VK_ERROR_DEVICE_LOST):
+            return "ERROR_DEVICE_LOST";
+        case (VK_ERROR_MEMORY_MAP_FAILED):
+            return "ERROR_MEMORY_MAP_FAILED";
+        case (VK_ERROR_LAYER_NOT_PRESENT):
+            return "ERROR_LAYER_NOT_PRESENT";
+        case (VK_ERROR_EXTENSION_NOT_PRESENT):
+            return "ERROR_EXTENSION_NOT_PRESENT";
+        case (VK_ERROR_FEATURE_NOT_PRESENT):
+            return "ERROR_FEATURE_NOT_PRESENT";
+        case (VK_ERROR_INCOMPATIBLE_DRIVER):
+            return "ERROR_INCOMPATIBLE_DRIVER";
+        case (VK_ERROR_TOO_MANY_OBJECTS):
+            return "ERROR_TOO_MANY_OBJECTS";
+        case (VK_ERROR_FORMAT_NOT_SUPPORTED):
+            return "ERROR_FORMAT_NOT_SUPPORTED";
+        case (VK_ERROR_FRAGMENTED_POOL):
+            return "ERROR_FRAGMENTED_POOL";
+        case (VK_ERROR_UNKNOWN):
+            return "ERROR_UNKNOWN";
+        case (VK_ERROR_VALIDATION_FAILED):
+            return "ERROR_VALIDATION_FAILED";
+        case (VK_ERROR_OUT_OF_POOL_MEMORY):
+            return "ERROR_OUT_OF_POOL_MEMORY";
+        case (VK_ERROR_INVALID_EXTERNAL_HANDLE):
+            return "ERROR_INVALID_EXTERNAL_HANDLE";
+        case (VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS):
+            return "ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS";
+        case (VK_ERROR_FRAGMENTATION):
+            return "ERROR_FRAGMENTATION";
+        case (VK_PIPELINE_COMPILE_REQUIRED):
+            return "PIPELINE_COMPILE_REQUIRED";
+        case (VK_ERROR_NOT_PERMITTED):
+            return "ERROR_NOT_PERMITTED";
+        case (VK_ERROR_SURFACE_LOST_KHR):
+            return "ERROR_SURFACE_LOST_KHR";
+        case (VK_ERROR_NATIVE_WINDOW_IN_USE_KHR):
+            return "ERROR_NATIVE_WINDOW_IN_USE_KHR";
+        case (VK_SUBOPTIMAL_KHR):
+            return "SUBOPTIMAL_KHR";
+        case (VK_ERROR_OUT_OF_DATE_KHR):
+            return "ERROR_OUT_OF_DATE_KHR";
+        case (VK_ERROR_INCOMPATIBLE_DISPLAY_KHR):
+            return "ERROR_INCOMPATIBLE_DISPLAY_KHR";
+        case (VK_ERROR_INVALID_SHADER_NV):
+            return "ERROR_INVALID_SHADER_NV";
+        case (VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR):
+            return "ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR";
+        case (VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR):
+            return "ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR";
+        case (VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR):
+            return "ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR";
+        case (VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR):
+            return "ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR";
+        case (VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR):
+            return "ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR";
+        case (VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR):
+            return "ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR";
+        case (VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT):
+            return "ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT";
+        case (VK_ERROR_PRESENT_TIMING_QUEUE_FULL_EXT):
+            return "ERROR_PRESENT_TIMING_QUEUE_FULL_EXT";
+        case (VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT):
+            return "ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT";
+        case (VK_THREAD_IDLE_KHR):
+            return "THREAD_IDLE_KHR";
+        case (VK_THREAD_DONE_KHR):
+            return "THREAD_DONE_KHR";
+        case (VK_OPERATION_DEFERRED_KHR):
+            return "OPERATION_DEFERRED_KHR";
+        case (VK_OPERATION_NOT_DEFERRED_KHR):
+            return "OPERATION_NOT_DEFERRED_KHR";
+        case (VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR):
+            return "ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR";
+        case (VK_ERROR_COMPRESSION_EXHAUSTED_EXT):
+            return "ERROR_COMPRESSION_EXHAUSTED_EXT";
+        case (VK_INCOMPATIBLE_SHADER_BINARY_EXT):
+            return "INCOMPATIBLE_SHADER_BINARY_EXT";
+        case (VK_PIPELINE_BINARY_MISSING_KHR):
+            return "PIPELINE_BINARY_MISSING_KHR";
+        case (VK_ERROR_NOT_ENOUGH_SPACE_KHR):
+            return "ERROR_NOT_ENOUGH_SPACE_KHR";
+        default:
+            return std::string("UNKNOWN_VkResult_value") + std::to_string(value);
+    }
+}
+void DumpVkResult(Printer &p, std::string name, VkResult value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkResultString(value));
+    else
+        p.PrintKeyString(name, VkResultString(value));
+}
+std::string VkScopeKHRString(VkScopeKHR value) {
+    switch (value) {
+        case (VK_SCOPE_DEVICE_KHR):
+            return "SCOPE_DEVICE_KHR";
+        case (VK_SCOPE_WORKGROUP_KHR):
+            return "SCOPE_WORKGROUP_KHR";
+        case (VK_SCOPE_SUBGROUP_KHR):
+            return "SCOPE_SUBGROUP_KHR";
+        case (VK_SCOPE_QUEUE_FAMILY_KHR):
+            return "SCOPE_QUEUE_FAMILY_KHR";
+        default:
+            return std::string("UNKNOWN_VkScopeKHR_value") + std::to_string(value);
+    }
+}
+void DumpVkScopeKHR(Printer &p, std::string name, VkScopeKHR value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkScopeKHRString(value));
+    else
+        p.PrintKeyString(name, VkScopeKHRString(value));
+}
+std::string VkShaderFloatControlsIndependenceString(VkShaderFloatControlsIndependence value) {
+    switch (value) {
+        case (VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY):
+            return "SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY";
+        case (VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL):
+            return "SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL";
+        case (VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE):
+            return "SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE";
+        default:
+            return std::string("UNKNOWN_VkShaderFloatControlsIndependence_value") + std::to_string(value);
+    }
+}
+void DumpVkShaderFloatControlsIndependence(Printer &p, std::string name, VkShaderFloatControlsIndependence value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkShaderFloatControlsIndependenceString(value));
+    else
+        p.PrintKeyString(name, VkShaderFloatControlsIndependenceString(value));
+}
+std::string VkTimeDomainKHRString(VkTimeDomainKHR value) {
+    switch (value) {
+        case (VK_TIME_DOMAIN_DEVICE_KHR):
+            return "TIME_DOMAIN_DEVICE_KHR";
+        case (VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR):
+            return "TIME_DOMAIN_CLOCK_MONOTONIC_KHR";
+        case (VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR):
+            return "TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR";
+        case (VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR):
+            return "TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR";
+        case (VK_TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT):
+            return "TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT";
+        case (VK_TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT):
+            return "TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT";
+        default:
+            return std::string("UNKNOWN_VkTimeDomainKHR_value") + std::to_string(value);
+    }
+}
+void DumpVkTimeDomainKHR(Printer &p, std::string name, VkTimeDomainKHR value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkTimeDomainKHRString(value));
+    else
+        p.PrintKeyString(name, VkTimeDomainKHRString(value));
+}
+std::string VkVideoEncodeTuningModeKHRString(VkVideoEncodeTuningModeKHR value) {
+    switch (value) {
+        case (VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR):
+            return "VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR";
+        case (VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR):
+            return "VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR";
+        case (VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR):
+            return "VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR";
+        case (VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR):
+            return "VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR";
+        case (VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR):
+            return "VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR";
+        default:
+            return std::string("UNKNOWN_VkVideoEncodeTuningModeKHR_value") + std::to_string(value);
+    }
+}
+void DumpVkVideoEncodeTuningModeKHR(Printer &p, std::string name, VkVideoEncodeTuningModeKHR value) {
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + VkVideoEncodeTuningModeKHRString(value));
+    else
+        p.PrintKeyString(name, VkVideoEncodeTuningModeKHRString(value));
+}
+std::vector<const char *> VkCompositeAlphaFlagBitsKHRGetStrings(VkCompositeAlphaFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR & value) strings.push_back("COMPOSITE_ALPHA_OPAQUE_BIT_KHR");
+    if (VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR & value) strings.push_back("COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR");
+    if (VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR & value) strings.push_back("COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR");
+    if (VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR & value) strings.push_back("COMPOSITE_ALPHA_INHERIT_BIT_KHR");
+    return strings;
+}
+void DumpVkCompositeAlphaFlagsKHR(Printer &p, std::string name, VkCompositeAlphaFlagsKHR value) {
+    if (static_cast<VkCompositeAlphaFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkCompositeAlphaFlagBitsKHRGetStrings(static_cast<VkCompositeAlphaFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkCompositeAlphaFlagBitsKHR(Printer &p, std::string name, VkCompositeAlphaFlagBitsKHR value) {
+    auto strings = VkCompositeAlphaFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkDeviceGroupPresentModeFlagBitsKHRGetStrings(VkDeviceGroupPresentModeFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR & value) strings.push_back("DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR");
+    if (VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR & value) strings.push_back("DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR");
+    if (VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR & value) strings.push_back("DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR");
+    if (VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR & value)
+        strings.push_back("DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR");
+    return strings;
+}
+void DumpVkDeviceGroupPresentModeFlagsKHR(Printer &p, std::string name, VkDeviceGroupPresentModeFlagsKHR value) {
+    if (static_cast<VkDeviceGroupPresentModeFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkDeviceGroupPresentModeFlagBitsKHRGetStrings(static_cast<VkDeviceGroupPresentModeFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkDeviceGroupPresentModeFlagBitsKHR(Printer &p, std::string name, VkDeviceGroupPresentModeFlagBitsKHR value) {
+    auto strings = VkDeviceGroupPresentModeFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkDisplayPlaneAlphaFlagBitsKHRGetStrings(VkDisplayPlaneAlphaFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR & value) strings.push_back("DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR");
+    if (VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR & value) strings.push_back("DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR");
+    if (VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR & value) strings.push_back("DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR");
+    if (VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR & value)
+        strings.push_back("DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR");
+    return strings;
+}
+void DumpVkDisplayPlaneAlphaFlagsKHR(Printer &p, std::string name, VkDisplayPlaneAlphaFlagsKHR value) {
+    if (static_cast<VkDisplayPlaneAlphaFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkDisplayPlaneAlphaFlagBitsKHRGetStrings(static_cast<VkDisplayPlaneAlphaFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkDisplayPlaneAlphaFlagBitsKHR(Printer &p, std::string name, VkDisplayPlaneAlphaFlagBitsKHR value) {
+    auto strings = VkDisplayPlaneAlphaFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkFormatFeatureFlagBitsGetStrings(VkFormatFeatureFlagBits value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT & value) strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_BIT");
+    if (VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT & value) strings.push_back("FORMAT_FEATURE_STORAGE_IMAGE_BIT");
+    if (VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT & value) strings.push_back("FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT");
+    if (VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT & value) strings.push_back("FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT");
+    if (VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT & value) strings.push_back("FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT");
+    if (VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT & value)
+        strings.push_back("FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT");
+    if (VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT & value) strings.push_back("FORMAT_FEATURE_VERTEX_BUFFER_BIT");
+    if (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT & value) strings.push_back("FORMAT_FEATURE_COLOR_ATTACHMENT_BIT");
+    if (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT & value) strings.push_back("FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT");
+    if (VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT & value) strings.push_back("FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT");
+    if (VK_FORMAT_FEATURE_BLIT_SRC_BIT & value) strings.push_back("FORMAT_FEATURE_BLIT_SRC_BIT");
+    if (VK_FORMAT_FEATURE_BLIT_DST_BIT & value) strings.push_back("FORMAT_FEATURE_BLIT_DST_BIT");
+    if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT & value)
+        strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT");
+    if (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT & value) strings.push_back("FORMAT_FEATURE_TRANSFER_SRC_BIT");
+    if (VK_FORMAT_FEATURE_TRANSFER_DST_BIT & value) strings.push_back("FORMAT_FEATURE_TRANSFER_DST_BIT");
+    if (VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT & value) strings.push_back("FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT");
+    if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT & value)
+        strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT");
+    if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT & value)
+        strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT");
+    if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT & value)
+        strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT");
+    if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT & value)
+        strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT");
+    if (VK_FORMAT_FEATURE_DISJOINT_BIT & value) strings.push_back("FORMAT_FEATURE_DISJOINT_BIT");
+    if (VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT & value) strings.push_back("FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT");
+    if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT & value)
+        strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT");
+    if (VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR");
+    if (VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR");
+    if (VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR & value)
+        strings.push_back("FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR");
+    if (VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT & value)
+        strings.push_back("FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT");
+    if (VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT & value) strings.push_back("FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT");
+    if (VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR & value)
+        strings.push_back("FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR");
+    if (VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR");
+    if (VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR");
+    return strings;
+}
+void DumpVkFormatFeatureFlags(Printer &p, std::string name, VkFormatFeatureFlags value) {
+    if (static_cast<VkFormatFeatureFlagBits>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkFormatFeatureFlagBitsGetStrings(static_cast<VkFormatFeatureFlagBits>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkFormatFeatureFlagBits(Printer &p, std::string name, VkFormatFeatureFlagBits value) {
+    auto strings = VkFormatFeatureFlagBitsGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkFormatFeatureFlagBits2GetStrings(VkFormatFeatureFlagBits2 value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT & value) strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT");
+    if (VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT & value) strings.push_back("FORMAT_FEATURE_2_STORAGE_IMAGE_BIT");
+    if (VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT & value) strings.push_back("FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT");
+    if (VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT & value) strings.push_back("FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT");
+    if (VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT & value) strings.push_back("FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT");
+    if (VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT & value)
+        strings.push_back("FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT");
+    if (VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT & value) strings.push_back("FORMAT_FEATURE_2_VERTEX_BUFFER_BIT");
+    if (VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT & value) strings.push_back("FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT");
+    if (VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT & value) strings.push_back("FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT");
+    if (VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT & value)
+        strings.push_back("FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT");
+    if (VK_FORMAT_FEATURE_2_BLIT_SRC_BIT & value) strings.push_back("FORMAT_FEATURE_2_BLIT_SRC_BIT");
+    if (VK_FORMAT_FEATURE_2_BLIT_DST_BIT & value) strings.push_back("FORMAT_FEATURE_2_BLIT_DST_BIT");
+    if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT & value)
+        strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT");
+    if (VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT & value) strings.push_back("FORMAT_FEATURE_2_TRANSFER_SRC_BIT");
+    if (VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT & value) strings.push_back("FORMAT_FEATURE_2_TRANSFER_DST_BIT");
+    if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT & value)
+        strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT");
+    if (VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT & value) strings.push_back("FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT");
+    if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT & value)
+        strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT");
+    if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT & value)
+        strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT");
+    if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT & value)
+        strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT");
+    if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT & value)
+        strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT");
+    if (VK_FORMAT_FEATURE_2_DISJOINT_BIT & value) strings.push_back("FORMAT_FEATURE_2_DISJOINT_BIT");
+    if (VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT & value) strings.push_back("FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT");
+    if (VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT & value)
+        strings.push_back("FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT");
+    if (VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT & value)
+        strings.push_back("FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT");
+    if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT & value)
+        strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT");
+    if (VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT & value)
+        strings.push_back("FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT");
+    if (VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT & value) strings.push_back("FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT");
+    if (VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR");
+    if (VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR");
+    if (VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR & value)
+        strings.push_back("FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR");
+    if (VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT & value)
+        strings.push_back("FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT");
+    if (VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR & value)
+        strings.push_back("FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR");
+    if (VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR");
+    if (VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR & value) strings.push_back("FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR");
+    if (VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV & value)
+        strings.push_back("FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV");
+    if (VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV & value)
+        strings.push_back("FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV");
+    if (VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM & value) strings.push_back("FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM");
+    if (VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM & value)
+        strings.push_back("FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM");
+    if (VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM & value) strings.push_back("FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM");
+    if (VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM & value) strings.push_back("FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM");
+    if (VK_FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM & value) strings.push_back("FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM");
+    if (VK_FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM & value)
+        strings.push_back("FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM");
+    if (VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV & value) strings.push_back("FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV");
+    if (VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV & value) strings.push_back("FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV");
+    if (VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV & value) strings.push_back("FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV");
+    if (VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM & value) strings.push_back("FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM");
+    if (VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR & value)
+        strings.push_back("FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR");
+    if (VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR & value)
+        strings.push_back("FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR");
+    if (VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR & value)
+        strings.push_back("FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR");
+    if (VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_QUEUE_BIT_KHR & value)
+        strings.push_back("FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_QUEUE_BIT_KHR");
+    if (VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR & value)
+        strings.push_back("FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR");
+    if (VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR & value)
+        strings.push_back("FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR");
+    if (VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR & value)
+        strings.push_back("FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR");
+    return strings;
+}
+void DumpVkFormatFeatureFlags2(Printer &p, std::string name, VkFormatFeatureFlags2 value) {
+    if (static_cast<VkFormatFeatureFlagBits2>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkFormatFeatureFlagBits2GetStrings(static_cast<VkFormatFeatureFlagBits2>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkFormatFeatureFlagBits2(Printer &p, std::string name, VkFormatFeatureFlagBits2 value) {
+    auto strings = VkFormatFeatureFlagBits2GetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkImageCreateFlagBitsGetStrings(VkImageCreateFlagBits value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_IMAGE_CREATE_SPARSE_BINDING_BIT & value) strings.push_back("IMAGE_CREATE_SPARSE_BINDING_BIT");
+    if (VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT & value) strings.push_back("IMAGE_CREATE_SPARSE_RESIDENCY_BIT");
+    if (VK_IMAGE_CREATE_SPARSE_ALIASED_BIT & value) strings.push_back("IMAGE_CREATE_SPARSE_ALIASED_BIT");
+    if (VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT & value) strings.push_back("IMAGE_CREATE_MUTABLE_FORMAT_BIT");
+    if (VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT & value) strings.push_back("IMAGE_CREATE_CUBE_COMPATIBLE_BIT");
+    if (VK_IMAGE_CREATE_ALIAS_BIT & value) strings.push_back("IMAGE_CREATE_ALIAS_BIT");
+    if (VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT & value) strings.push_back("IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT");
+    if (VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT & value) strings.push_back("IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT");
+    if (VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT & value) strings.push_back("IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT");
+    if (VK_IMAGE_CREATE_EXTENDED_USAGE_BIT & value) strings.push_back("IMAGE_CREATE_EXTENDED_USAGE_BIT");
+    if (VK_IMAGE_CREATE_PROTECTED_BIT & value) strings.push_back("IMAGE_CREATE_PROTECTED_BIT");
+    if (VK_IMAGE_CREATE_DISJOINT_BIT & value) strings.push_back("IMAGE_CREATE_DISJOINT_BIT");
+    if (VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV & value) strings.push_back("IMAGE_CREATE_CORNER_SAMPLED_BIT_NV");
+    if (VK_IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT & value)
+        strings.push_back("IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT");
+    if (VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT & value)
+        strings.push_back("IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT");
+    if (VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT & value) strings.push_back("IMAGE_CREATE_SUBSAMPLED_BIT_EXT");
+    if (VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT & value)
+        strings.push_back("IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT");
+    if (VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT & value) strings.push_back("IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT");
+    if (VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR & value)
+        strings.push_back("IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR");
+    if (VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT & value)
+        strings.push_back("IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT");
+    return strings;
+}
+void DumpVkImageCreateFlags(Printer &p, std::string name, VkImageCreateFlags value) {
+    if (static_cast<VkImageCreateFlagBits>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkImageCreateFlagBitsGetStrings(static_cast<VkImageCreateFlagBits>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkImageCreateFlagBits(Printer &p, std::string name, VkImageCreateFlagBits value) {
+    auto strings = VkImageCreateFlagBitsGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkImageUsageFlagBitsGetStrings(VkImageUsageFlagBits value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_IMAGE_USAGE_TRANSFER_SRC_BIT & value) strings.push_back("IMAGE_USAGE_TRANSFER_SRC_BIT");
+    if (VK_IMAGE_USAGE_TRANSFER_DST_BIT & value) strings.push_back("IMAGE_USAGE_TRANSFER_DST_BIT");
+    if (VK_IMAGE_USAGE_SAMPLED_BIT & value) strings.push_back("IMAGE_USAGE_SAMPLED_BIT");
+    if (VK_IMAGE_USAGE_STORAGE_BIT & value) strings.push_back("IMAGE_USAGE_STORAGE_BIT");
+    if (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT & value) strings.push_back("IMAGE_USAGE_COLOR_ATTACHMENT_BIT");
+    if (VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT & value) strings.push_back("IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT");
+    if (VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT & value) strings.push_back("IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT");
+    if (VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT & value) strings.push_back("IMAGE_USAGE_INPUT_ATTACHMENT_BIT");
+    if (VK_IMAGE_USAGE_HOST_TRANSFER_BIT & value) strings.push_back("IMAGE_USAGE_HOST_TRANSFER_BIT");
+    if (VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR & value) strings.push_back("IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR");
+    if (VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR & value) strings.push_back("IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR");
+    if (VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR & value) strings.push_back("IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR");
+    if (VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT & value) strings.push_back("IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT");
+    if (VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR & value)
+        strings.push_back("IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR");
+    if (VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR & value) strings.push_back("IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR");
+    if (VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR & value) strings.push_back("IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR");
+    if (VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR & value) strings.push_back("IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR");
+    if (VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT & value) strings.push_back("IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT");
+    if (VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI & value) strings.push_back("IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI");
+    if (VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM & value) strings.push_back("IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM");
+    if (VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM & value) strings.push_back("IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM");
+    if (VK_IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM & value) strings.push_back("IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM");
+    if (VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM & value) strings.push_back("IMAGE_USAGE_TILE_MEMORY_BIT_QCOM");
+    if (VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR & value)
+        strings.push_back("IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR");
+    if (VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR & value)
+        strings.push_back("IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR");
+    return strings;
+}
+void DumpVkImageUsageFlags(Printer &p, std::string name, VkImageUsageFlags value) {
+    if (static_cast<VkImageUsageFlagBits>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkImageUsageFlagBitsGetStrings(static_cast<VkImageUsageFlagBits>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkImageUsageFlagBits(Printer &p, std::string name, VkImageUsageFlagBits value) {
+    auto strings = VkImageUsageFlagBitsGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkIndirectCommandsInputModeFlagBitsEXTGetStrings(VkIndirectCommandsInputModeFlagBitsEXT value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT & value)
+        strings.push_back("INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT");
+    if (VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT & value)
+        strings.push_back("INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT");
+    return strings;
+}
+void DumpVkIndirectCommandsInputModeFlagsEXT(Printer &p, std::string name, VkIndirectCommandsInputModeFlagsEXT value) {
+    if (static_cast<VkIndirectCommandsInputModeFlagBitsEXT>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkIndirectCommandsInputModeFlagBitsEXTGetStrings(static_cast<VkIndirectCommandsInputModeFlagBitsEXT>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkIndirectCommandsInputModeFlagBitsEXT(Printer &p, std::string name, VkIndirectCommandsInputModeFlagBitsEXT value) {
+    auto strings = VkIndirectCommandsInputModeFlagBitsEXTGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkMemoryDecompressionMethodFlagBitsEXTGetStrings(VkMemoryDecompressionMethodFlagBitsEXT value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT & value)
+        strings.push_back("MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT");
+    return strings;
+}
+void DumpVkMemoryDecompressionMethodFlagsEXT(Printer &p, std::string name, VkMemoryDecompressionMethodFlagsEXT value) {
+    if (static_cast<VkMemoryDecompressionMethodFlagBitsEXT>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkMemoryDecompressionMethodFlagBitsEXTGetStrings(static_cast<VkMemoryDecompressionMethodFlagBitsEXT>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkMemoryDecompressionMethodFlagBitsEXT(Printer &p, std::string name, VkMemoryDecompressionMethodFlagBitsEXT value) {
+    auto strings = VkMemoryDecompressionMethodFlagBitsEXTGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkMemoryHeapFlagBitsGetStrings(VkMemoryHeapFlagBits value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_MEMORY_HEAP_DEVICE_LOCAL_BIT & value) strings.push_back("MEMORY_HEAP_DEVICE_LOCAL_BIT");
+    if (VK_MEMORY_HEAP_MULTI_INSTANCE_BIT & value) strings.push_back("MEMORY_HEAP_MULTI_INSTANCE_BIT");
+    if (VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM & value) strings.push_back("MEMORY_HEAP_TILE_MEMORY_BIT_QCOM");
+    return strings;
+}
+void DumpVkMemoryHeapFlags(Printer &p, std::string name, VkMemoryHeapFlags value) {
+    if (static_cast<VkMemoryHeapFlagBits>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkMemoryHeapFlagBitsGetStrings(static_cast<VkMemoryHeapFlagBits>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkMemoryHeapFlagBits(Printer &p, std::string name, VkMemoryHeapFlagBits value) {
+    auto strings = VkMemoryHeapFlagBitsGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkMemoryPropertyFlagBitsGetStrings(VkMemoryPropertyFlagBits value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT & value) strings.push_back("MEMORY_PROPERTY_DEVICE_LOCAL_BIT");
+    if (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT & value) strings.push_back("MEMORY_PROPERTY_HOST_VISIBLE_BIT");
+    if (VK_MEMORY_PROPERTY_HOST_COHERENT_BIT & value) strings.push_back("MEMORY_PROPERTY_HOST_COHERENT_BIT");
+    if (VK_MEMORY_PROPERTY_HOST_CACHED_BIT & value) strings.push_back("MEMORY_PROPERTY_HOST_CACHED_BIT");
+    if (VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT & value) strings.push_back("MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT");
+    if (VK_MEMORY_PROPERTY_PROTECTED_BIT & value) strings.push_back("MEMORY_PROPERTY_PROTECTED_BIT");
+    if (VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD & value) strings.push_back("MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD");
+    if (VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD & value) strings.push_back("MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD");
+    if (VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV & value) strings.push_back("MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV");
+    return strings;
+}
+void DumpVkMemoryPropertyFlags(Printer &p, std::string name, VkMemoryPropertyFlags value) {
+    if (static_cast<VkMemoryPropertyFlagBits>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkMemoryPropertyFlagBitsGetStrings(static_cast<VkMemoryPropertyFlagBits>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkMemoryPropertyFlagBits(Printer &p, std::string name, VkMemoryPropertyFlagBits value) {
+    auto strings = VkMemoryPropertyFlagBitsGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkPresentGravityFlagBitsKHRGetStrings(VkPresentGravityFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_PRESENT_GRAVITY_MIN_BIT_KHR & value) strings.push_back("PRESENT_GRAVITY_MIN_BIT_KHR");
+    if (VK_PRESENT_GRAVITY_MAX_BIT_KHR & value) strings.push_back("PRESENT_GRAVITY_MAX_BIT_KHR");
+    if (VK_PRESENT_GRAVITY_CENTERED_BIT_KHR & value) strings.push_back("PRESENT_GRAVITY_CENTERED_BIT_KHR");
+    return strings;
+}
+void DumpVkPresentGravityFlagsKHR(Printer &p, std::string name, VkPresentGravityFlagsKHR value) {
+    if (static_cast<VkPresentGravityFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkPresentGravityFlagBitsKHRGetStrings(static_cast<VkPresentGravityFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkPresentGravityFlagBitsKHR(Printer &p, std::string name, VkPresentGravityFlagBitsKHR value) {
+    auto strings = VkPresentGravityFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkPresentScalingFlagBitsKHRGetStrings(VkPresentScalingFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR & value) strings.push_back("PRESENT_SCALING_ONE_TO_ONE_BIT_KHR");
+    if (VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR & value) strings.push_back("PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR");
+    if (VK_PRESENT_SCALING_STRETCH_BIT_KHR & value) strings.push_back("PRESENT_SCALING_STRETCH_BIT_KHR");
+    return strings;
+}
+void DumpVkPresentScalingFlagsKHR(Printer &p, std::string name, VkPresentScalingFlagsKHR value) {
+    if (static_cast<VkPresentScalingFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkPresentScalingFlagBitsKHRGetStrings(static_cast<VkPresentScalingFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkPresentScalingFlagBitsKHR(Printer &p, std::string name, VkPresentScalingFlagBitsKHR value) {
+    auto strings = VkPresentScalingFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkPresentStageFlagBitsEXTGetStrings(VkPresentStageFlagBitsEXT value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT & value) strings.push_back("PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT");
+    if (VK_PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT & value) strings.push_back("PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT");
+    if (VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT & value) strings.push_back("PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT");
+    if (VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT & value)
+        strings.push_back("PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT");
+    return strings;
+}
+void DumpVkPresentStageFlagsEXT(Printer &p, std::string name, VkPresentStageFlagsEXT value) {
+    if (static_cast<VkPresentStageFlagBitsEXT>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkPresentStageFlagBitsEXTGetStrings(static_cast<VkPresentStageFlagBitsEXT>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkPresentStageFlagBitsEXT(Printer &p, std::string name, VkPresentStageFlagBitsEXT value) {
+    auto strings = VkPresentStageFlagBitsEXTGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkQueueFlagBitsGetStrings(VkQueueFlagBits value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_QUEUE_GRAPHICS_BIT & value) strings.push_back("QUEUE_GRAPHICS_BIT");
+    if (VK_QUEUE_COMPUTE_BIT & value) strings.push_back("QUEUE_COMPUTE_BIT");
+    if (VK_QUEUE_TRANSFER_BIT & value) strings.push_back("QUEUE_TRANSFER_BIT");
+    if (VK_QUEUE_SPARSE_BINDING_BIT & value) strings.push_back("QUEUE_SPARSE_BINDING_BIT");
+    if (VK_QUEUE_PROTECTED_BIT & value) strings.push_back("QUEUE_PROTECTED_BIT");
+    if (VK_QUEUE_VIDEO_DECODE_BIT_KHR & value) strings.push_back("QUEUE_VIDEO_DECODE_BIT_KHR");
+    if (VK_QUEUE_VIDEO_ENCODE_BIT_KHR & value) strings.push_back("QUEUE_VIDEO_ENCODE_BIT_KHR");
+    if (VK_QUEUE_OPTICAL_FLOW_BIT_NV & value) strings.push_back("QUEUE_OPTICAL_FLOW_BIT_NV");
+    if (VK_QUEUE_DATA_GRAPH_BIT_ARM & value) strings.push_back("QUEUE_DATA_GRAPH_BIT_ARM");
+    return strings;
+}
+void DumpVkQueueFlags(Printer &p, std::string name, VkQueueFlags value) {
+    if (static_cast<VkQueueFlagBits>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkQueueFlagBitsGetStrings(static_cast<VkQueueFlagBits>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkQueueFlagBits(Printer &p, std::string name, VkQueueFlagBits value) {
+    auto strings = VkQueueFlagBitsGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::string VkQueueFlagsString(VkQueueFlags value) {
+    std::string out;
+    bool is_first = true;
+    if (VK_QUEUE_GRAPHICS_BIT & value) {
+        if (is_first) {
+            is_first = false;
+        } else {
+            out += " | ";
+        }
+        out += "QUEUE_GRAPHICS_BIT";
+    }
+    if (VK_QUEUE_COMPUTE_BIT & value) {
+        if (is_first) {
+            is_first = false;
+        } else {
+            out += " | ";
+        }
+        out += "QUEUE_COMPUTE_BIT";
+    }
+    if (VK_QUEUE_TRANSFER_BIT & value) {
+        if (is_first) {
+            is_first = false;
+        } else {
+            out += " | ";
+        }
+        out += "QUEUE_TRANSFER_BIT";
+    }
+    if (VK_QUEUE_SPARSE_BINDING_BIT & value) {
+        if (is_first) {
+            is_first = false;
+        } else {
+            out += " | ";
+        }
+        out += "QUEUE_SPARSE_BINDING_BIT";
+    }
+    if (VK_QUEUE_PROTECTED_BIT & value) {
+        if (is_first) {
+            is_first = false;
+        } else {
+            out += " | ";
+        }
+        out += "QUEUE_PROTECTED_BIT";
+    }
+    if (VK_QUEUE_VIDEO_DECODE_BIT_KHR & value) {
+        if (is_first) {
+            is_first = false;
+        } else {
+            out += " | ";
+        }
+        out += "QUEUE_VIDEO_DECODE_BIT_KHR";
+    }
+    if (VK_QUEUE_VIDEO_ENCODE_BIT_KHR & value) {
+        if (is_first) {
+            is_first = false;
+        } else {
+            out += " | ";
+        }
+        out += "QUEUE_VIDEO_ENCODE_BIT_KHR";
+    }
+    if (VK_QUEUE_OPTICAL_FLOW_BIT_NV & value) {
+        if (is_first) {
+            is_first = false;
+        } else {
+            out += " | ";
+        }
+        out += "QUEUE_OPTICAL_FLOW_BIT_NV";
+    }
+    if (VK_QUEUE_DATA_GRAPH_BIT_ARM & value) {
+        if (is_first) {
+            is_first = false;
+        } else {
+            out += " | ";
+        }
+        out += "QUEUE_DATA_GRAPH_BIT_ARM";
+    }
+    return out;
+}
+std::vector<const char *> VkResolveModeFlagBitsGetStrings(VkResolveModeFlagBits value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("RESOLVE_MODE_NONE");
+        return strings;
+    }
+    if (VK_RESOLVE_MODE_SAMPLE_ZERO_BIT & value) strings.push_back("RESOLVE_MODE_SAMPLE_ZERO_BIT");
+    if (VK_RESOLVE_MODE_AVERAGE_BIT & value) strings.push_back("RESOLVE_MODE_AVERAGE_BIT");
+    if (VK_RESOLVE_MODE_MIN_BIT & value) strings.push_back("RESOLVE_MODE_MIN_BIT");
+    if (VK_RESOLVE_MODE_MAX_BIT & value) strings.push_back("RESOLVE_MODE_MAX_BIT");
+    if (VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID & value)
+        strings.push_back("RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID");
+    if (VK_RESOLVE_MODE_CUSTOM_BIT_EXT & value) strings.push_back("RESOLVE_MODE_CUSTOM_BIT_EXT");
+    return strings;
+}
+void DumpVkResolveModeFlags(Printer &p, std::string name, VkResolveModeFlags value) {
+    if (static_cast<VkResolveModeFlagBits>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkResolveModeFlagBitsGetStrings(static_cast<VkResolveModeFlagBits>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkResolveModeFlagBits(Printer &p, std::string name, VkResolveModeFlagBits value) {
+    auto strings = VkResolveModeFlagBitsGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkSampleCountFlagBitsGetStrings(VkSampleCountFlagBits value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_SAMPLE_COUNT_1_BIT & value) strings.push_back("SAMPLE_COUNT_1_BIT");
+    if (VK_SAMPLE_COUNT_2_BIT & value) strings.push_back("SAMPLE_COUNT_2_BIT");
+    if (VK_SAMPLE_COUNT_4_BIT & value) strings.push_back("SAMPLE_COUNT_4_BIT");
+    if (VK_SAMPLE_COUNT_8_BIT & value) strings.push_back("SAMPLE_COUNT_8_BIT");
+    if (VK_SAMPLE_COUNT_16_BIT & value) strings.push_back("SAMPLE_COUNT_16_BIT");
+    if (VK_SAMPLE_COUNT_32_BIT & value) strings.push_back("SAMPLE_COUNT_32_BIT");
+    if (VK_SAMPLE_COUNT_64_BIT & value) strings.push_back("SAMPLE_COUNT_64_BIT");
+    return strings;
+}
+void DumpVkSampleCountFlags(Printer &p, std::string name, VkSampleCountFlags value) {
+    if (static_cast<VkSampleCountFlagBits>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkSampleCountFlagBitsGetStrings(static_cast<VkSampleCountFlagBits>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkSampleCountFlagBits(Printer &p, std::string name, VkSampleCountFlagBits value) {
+    auto strings = VkSampleCountFlagBitsGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkShaderStageFlagBitsGetStrings(VkShaderStageFlagBits value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_SHADER_STAGE_VERTEX_BIT & value) strings.push_back("SHADER_STAGE_VERTEX_BIT");
+    if (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT & value) strings.push_back("SHADER_STAGE_TESSELLATION_CONTROL_BIT");
+    if (VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT & value) strings.push_back("SHADER_STAGE_TESSELLATION_EVALUATION_BIT");
+    if (VK_SHADER_STAGE_GEOMETRY_BIT & value) strings.push_back("SHADER_STAGE_GEOMETRY_BIT");
+    if (VK_SHADER_STAGE_FRAGMENT_BIT & value) strings.push_back("SHADER_STAGE_FRAGMENT_BIT");
+    if (VK_SHADER_STAGE_COMPUTE_BIT & value) strings.push_back("SHADER_STAGE_COMPUTE_BIT");
+    if (VK_SHADER_STAGE_RAYGEN_BIT_KHR & value) strings.push_back("SHADER_STAGE_RAYGEN_BIT_KHR");
+    if (VK_SHADER_STAGE_ANY_HIT_BIT_KHR & value) strings.push_back("SHADER_STAGE_ANY_HIT_BIT_KHR");
+    if (VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR & value) strings.push_back("SHADER_STAGE_CLOSEST_HIT_BIT_KHR");
+    if (VK_SHADER_STAGE_MISS_BIT_KHR & value) strings.push_back("SHADER_STAGE_MISS_BIT_KHR");
+    if (VK_SHADER_STAGE_INTERSECTION_BIT_KHR & value) strings.push_back("SHADER_STAGE_INTERSECTION_BIT_KHR");
+    if (VK_SHADER_STAGE_CALLABLE_BIT_KHR & value) strings.push_back("SHADER_STAGE_CALLABLE_BIT_KHR");
+    if (VK_SHADER_STAGE_TASK_BIT_EXT & value) strings.push_back("SHADER_STAGE_TASK_BIT_EXT");
+    if (VK_SHADER_STAGE_MESH_BIT_EXT & value) strings.push_back("SHADER_STAGE_MESH_BIT_EXT");
+    if (VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI & value) strings.push_back("SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI");
+    if (VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI & value) strings.push_back("SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI");
+    return strings;
+}
+void DumpVkShaderStageFlags(Printer &p, std::string name, VkShaderStageFlags value) {
+    if (static_cast<VkShaderStageFlagBits>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkShaderStageFlagBitsGetStrings(static_cast<VkShaderStageFlagBits>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkShaderStageFlagBits(Printer &p, std::string name, VkShaderStageFlagBits value) {
+    auto strings = VkShaderStageFlagBitsGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkSubgroupFeatureFlagBitsGetStrings(VkSubgroupFeatureFlagBits value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_SUBGROUP_FEATURE_BASIC_BIT & value) strings.push_back("SUBGROUP_FEATURE_BASIC_BIT");
+    if (VK_SUBGROUP_FEATURE_VOTE_BIT & value) strings.push_back("SUBGROUP_FEATURE_VOTE_BIT");
+    if (VK_SUBGROUP_FEATURE_ARITHMETIC_BIT & value) strings.push_back("SUBGROUP_FEATURE_ARITHMETIC_BIT");
+    if (VK_SUBGROUP_FEATURE_BALLOT_BIT & value) strings.push_back("SUBGROUP_FEATURE_BALLOT_BIT");
+    if (VK_SUBGROUP_FEATURE_SHUFFLE_BIT & value) strings.push_back("SUBGROUP_FEATURE_SHUFFLE_BIT");
+    if (VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT & value) strings.push_back("SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT");
+    if (VK_SUBGROUP_FEATURE_CLUSTERED_BIT & value) strings.push_back("SUBGROUP_FEATURE_CLUSTERED_BIT");
+    if (VK_SUBGROUP_FEATURE_QUAD_BIT & value) strings.push_back("SUBGROUP_FEATURE_QUAD_BIT");
+    if (VK_SUBGROUP_FEATURE_ROTATE_BIT & value) strings.push_back("SUBGROUP_FEATURE_ROTATE_BIT");
+    if (VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT & value) strings.push_back("SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT");
+    if (VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT & value) strings.push_back("SUBGROUP_FEATURE_PARTITIONED_BIT_EXT");
+    return strings;
+}
+void DumpVkSubgroupFeatureFlags(Printer &p, std::string name, VkSubgroupFeatureFlags value) {
+    if (static_cast<VkSubgroupFeatureFlagBits>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkSubgroupFeatureFlagBitsGetStrings(static_cast<VkSubgroupFeatureFlagBits>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkSubgroupFeatureFlagBits(Printer &p, std::string name, VkSubgroupFeatureFlagBits value) {
+    auto strings = VkSubgroupFeatureFlagBitsGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkSurfaceCounterFlagBitsEXTGetStrings(VkSurfaceCounterFlagBitsEXT value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_SURFACE_COUNTER_VBLANK_BIT_EXT & value) strings.push_back("SURFACE_COUNTER_VBLANK_BIT_EXT");
+    return strings;
+}
+void DumpVkSurfaceCounterFlagsEXT(Printer &p, std::string name, VkSurfaceCounterFlagsEXT value) {
+    if (static_cast<VkSurfaceCounterFlagBitsEXT>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkSurfaceCounterFlagBitsEXTGetStrings(static_cast<VkSurfaceCounterFlagBitsEXT>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkSurfaceCounterFlagBitsEXT(Printer &p, std::string name, VkSurfaceCounterFlagBitsEXT value) {
+    auto strings = VkSurfaceCounterFlagBitsEXTGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkSurfaceTransformFlagBitsKHRGetStrings(VkSurfaceTransformFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR & value) strings.push_back("SURFACE_TRANSFORM_IDENTITY_BIT_KHR");
+    if (VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR & value) strings.push_back("SURFACE_TRANSFORM_ROTATE_90_BIT_KHR");
+    if (VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR & value) strings.push_back("SURFACE_TRANSFORM_ROTATE_180_BIT_KHR");
+    if (VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR & value) strings.push_back("SURFACE_TRANSFORM_ROTATE_270_BIT_KHR");
+    if (VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR & value) strings.push_back("SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR");
+    if (VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR & value)
+        strings.push_back("SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR");
+    if (VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR & value)
+        strings.push_back("SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR");
+    if (VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR & value)
+        strings.push_back("SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR");
+    if (VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR & value) strings.push_back("SURFACE_TRANSFORM_INHERIT_BIT_KHR");
+    return strings;
+}
+void DumpVkSurfaceTransformFlagsKHR(Printer &p, std::string name, VkSurfaceTransformFlagsKHR value) {
+    if (static_cast<VkSurfaceTransformFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkSurfaceTransformFlagBitsKHRGetStrings(static_cast<VkSurfaceTransformFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkSurfaceTransformFlagBitsKHR(Printer &p, std::string name, VkSurfaceTransformFlagBitsKHR value) {
+    auto strings = VkSurfaceTransformFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkToolPurposeFlagBitsGetStrings(VkToolPurposeFlagBits value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_TOOL_PURPOSE_VALIDATION_BIT & value) strings.push_back("TOOL_PURPOSE_VALIDATION_BIT");
+    if (VK_TOOL_PURPOSE_PROFILING_BIT & value) strings.push_back("TOOL_PURPOSE_PROFILING_BIT");
+    if (VK_TOOL_PURPOSE_TRACING_BIT & value) strings.push_back("TOOL_PURPOSE_TRACING_BIT");
+    if (VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT & value) strings.push_back("TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT");
+    if (VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT & value) strings.push_back("TOOL_PURPOSE_MODIFYING_FEATURES_BIT");
+    if (VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT & value) strings.push_back("TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT");
+    if (VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT & value) strings.push_back("TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT");
+    return strings;
+}
+void DumpVkToolPurposeFlags(Printer &p, std::string name, VkToolPurposeFlags value) {
+    if (static_cast<VkToolPurposeFlagBits>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkToolPurposeFlagBitsGetStrings(static_cast<VkToolPurposeFlagBits>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkToolPurposeFlagBits(Printer &p, std::string name, VkToolPurposeFlagBits value) {
+    auto strings = VkToolPurposeFlagBitsGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoCapabilityFlagBitsKHRGetStrings(VkVideoCapabilityFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR & value) strings.push_back("VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR");
+    if (VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR & value)
+        strings.push_back("VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoCapabilityFlagsKHR(Printer &p, std::string name, VkVideoCapabilityFlagsKHR value) {
+    if (static_cast<VkVideoCapabilityFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoCapabilityFlagBitsKHRGetStrings(static_cast<VkVideoCapabilityFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoCapabilityFlagBitsKHR(Printer &p, std::string name, VkVideoCapabilityFlagBitsKHR value) {
+    auto strings = VkVideoCapabilityFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoChromaSubsamplingFlagBitsKHRGetStrings(VkVideoChromaSubsamplingFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR");
+        return strings;
+    }
+    if (VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR & value) strings.push_back("VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR");
+    if (VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR & value) strings.push_back("VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR");
+    if (VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR & value) strings.push_back("VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR");
+    if (VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR & value) strings.push_back("VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoChromaSubsamplingFlagsKHR(Printer &p, std::string name, VkVideoChromaSubsamplingFlagsKHR value) {
+    if (static_cast<VkVideoChromaSubsamplingFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoChromaSubsamplingFlagBitsKHRGetStrings(static_cast<VkVideoChromaSubsamplingFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoChromaSubsamplingFlagBitsKHR(Printer &p, std::string name, VkVideoChromaSubsamplingFlagBitsKHR value) {
+    auto strings = VkVideoChromaSubsamplingFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoCodecOperationFlagBitsKHRGetStrings(VkVideoCodecOperationFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("VIDEO_CODEC_OPERATION_NONE_KHR");
+        return strings;
+    }
+    if (VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR");
+    if (VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR");
+    if (VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR");
+    if (VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR");
+    if (VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR");
+    if (VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR");
+    if (VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR & value) strings.push_back("VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoCodecOperationFlagsKHR(Printer &p, std::string name, VkVideoCodecOperationFlagsKHR value) {
+    if (static_cast<VkVideoCodecOperationFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoCodecOperationFlagBitsKHRGetStrings(static_cast<VkVideoCodecOperationFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoCodecOperationFlagBitsKHR(Printer &p, std::string name, VkVideoCodecOperationFlagBitsKHR value) {
+    auto strings = VkVideoCodecOperationFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoComponentBitDepthFlagBitsKHRGetStrings(VkVideoComponentBitDepthFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR");
+        return strings;
+    }
+    if (VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR & value) strings.push_back("VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR");
+    if (VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR & value) strings.push_back("VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR");
+    if (VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR & value) strings.push_back("VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoComponentBitDepthFlagsKHR(Printer &p, std::string name, VkVideoComponentBitDepthFlagsKHR value) {
+    if (static_cast<VkVideoComponentBitDepthFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoComponentBitDepthFlagBitsKHRGetStrings(static_cast<VkVideoComponentBitDepthFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoComponentBitDepthFlagBitsKHR(Printer &p, std::string name, VkVideoComponentBitDepthFlagBitsKHR value) {
+    auto strings = VkVideoComponentBitDepthFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoDecodeCapabilityFlagBitsKHRGetStrings(VkVideoDecodeCapabilityFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR & value)
+        strings.push_back("VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR");
+    if (VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR & value)
+        strings.push_back("VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoDecodeCapabilityFlagsKHR(Printer &p, std::string name, VkVideoDecodeCapabilityFlagsKHR value) {
+    if (static_cast<VkVideoDecodeCapabilityFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoDecodeCapabilityFlagBitsKHRGetStrings(static_cast<VkVideoDecodeCapabilityFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoDecodeCapabilityFlagBitsKHR(Printer &p, std::string name, VkVideoDecodeCapabilityFlagBitsKHR value) {
+    auto strings = VkVideoDecodeCapabilityFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoDecodeH264PictureLayoutFlagBitsKHRGetStrings(VkVideoDecodeH264PictureLayoutFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR");
+        return strings;
+    }
+    if (VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR & value)
+        strings.push_back("VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR");
+    if (VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR & value)
+        strings.push_back("VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoDecodeH264PictureLayoutFlagsKHR(Printer &p, std::string name, VkVideoDecodeH264PictureLayoutFlagsKHR value) {
+    if (static_cast<VkVideoDecodeH264PictureLayoutFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings =
+        VkVideoDecodeH264PictureLayoutFlagBitsKHRGetStrings(static_cast<VkVideoDecodeH264PictureLayoutFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoDecodeH264PictureLayoutFlagBitsKHR(Printer &p, std::string name, VkVideoDecodeH264PictureLayoutFlagBitsKHR value) {
+    auto strings = VkVideoDecodeH264PictureLayoutFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoDecodeUsageFlagBitsKHRGetStrings(VkVideoDecodeUsageFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("VIDEO_DECODE_USAGE_DEFAULT_KHR");
+        return strings;
+    }
+    if (VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR & value) strings.push_back("VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR");
+    if (VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR & value) strings.push_back("VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR");
+    if (VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR & value) strings.push_back("VIDEO_DECODE_USAGE_STREAMING_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoDecodeUsageFlagsKHR(Printer &p, std::string name, VkVideoDecodeUsageFlagsKHR value) {
+    if (static_cast<VkVideoDecodeUsageFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoDecodeUsageFlagBitsKHRGetStrings(static_cast<VkVideoDecodeUsageFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoDecodeUsageFlagBitsKHR(Printer &p, std::string name, VkVideoDecodeUsageFlagBitsKHR value) {
+    auto strings = VkVideoDecodeUsageFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeAV1CapabilityFlagBitsKHRGetStrings(VkVideoEncodeAV1CapabilityFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR");
+    if (VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR");
+    if (VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR");
+    if (VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR");
+    if (VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR");
+    if (VK_VIDEO_ENCODE_AV1_CAPABILITY_COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_AV1_CAPABILITY_COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeAV1CapabilityFlagsKHR(Printer &p, std::string name, VkVideoEncodeAV1CapabilityFlagsKHR value) {
+    if (static_cast<VkVideoEncodeAV1CapabilityFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeAV1CapabilityFlagBitsKHRGetStrings(static_cast<VkVideoEncodeAV1CapabilityFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeAV1CapabilityFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeAV1CapabilityFlagBitsKHR value) {
+    auto strings = VkVideoEncodeAV1CapabilityFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeAV1StdFlagBitsKHRGetStrings(VkVideoEncodeAV1StdFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR");
+    if (VK_VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeAV1StdFlagsKHR(Printer &p, std::string name, VkVideoEncodeAV1StdFlagsKHR value) {
+    if (static_cast<VkVideoEncodeAV1StdFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeAV1StdFlagBitsKHRGetStrings(static_cast<VkVideoEncodeAV1StdFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeAV1StdFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeAV1StdFlagBitsKHR value) {
+    auto strings = VkVideoEncodeAV1StdFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeAV1SuperblockSizeFlagBitsKHRGetStrings(VkVideoEncodeAV1SuperblockSizeFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR");
+    if (VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeAV1SuperblockSizeFlagsKHR(Printer &p, std::string name, VkVideoEncodeAV1SuperblockSizeFlagsKHR value) {
+    if (static_cast<VkVideoEncodeAV1SuperblockSizeFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings =
+        VkVideoEncodeAV1SuperblockSizeFlagBitsKHRGetStrings(static_cast<VkVideoEncodeAV1SuperblockSizeFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeAV1SuperblockSizeFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeAV1SuperblockSizeFlagBitsKHR value) {
+    auto strings = VkVideoEncodeAV1SuperblockSizeFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeCapabilityFlagBitsKHRGetStrings(VkVideoEncodeCapabilityFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR");
+    if (VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR");
+    if (VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR");
+    if (VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeCapabilityFlagsKHR(Printer &p, std::string name, VkVideoEncodeCapabilityFlagsKHR value) {
+    if (static_cast<VkVideoEncodeCapabilityFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeCapabilityFlagBitsKHRGetStrings(static_cast<VkVideoEncodeCapabilityFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeCapabilityFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeCapabilityFlagBitsKHR value) {
+    auto strings = VkVideoEncodeCapabilityFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeContentFlagBitsKHRGetStrings(VkVideoEncodeContentFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("VIDEO_ENCODE_CONTENT_DEFAULT_KHR");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR");
+    if (VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR");
+    if (VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeContentFlagsKHR(Printer &p, std::string name, VkVideoEncodeContentFlagsKHR value) {
+    if (static_cast<VkVideoEncodeContentFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeContentFlagBitsKHRGetStrings(static_cast<VkVideoEncodeContentFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeContentFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeContentFlagBitsKHR value) {
+    auto strings = VkVideoEncodeContentFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeFeedbackFlagBitsKHRGetStrings(VkVideoEncodeFeedbackFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR");
+    if (VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeFeedbackFlagsKHR(Printer &p, std::string name, VkVideoEncodeFeedbackFlagsKHR value) {
+    if (static_cast<VkVideoEncodeFeedbackFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeFeedbackFlagBitsKHRGetStrings(static_cast<VkVideoEncodeFeedbackFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeFeedbackFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeFeedbackFlagBitsKHR value) {
+    auto strings = VkVideoEncodeFeedbackFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeH264CapabilityFlagBitsKHRGetStrings(VkVideoEncodeH264CapabilityFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeH264CapabilityFlagsKHR(Printer &p, std::string name, VkVideoEncodeH264CapabilityFlagsKHR value) {
+    if (static_cast<VkVideoEncodeH264CapabilityFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeH264CapabilityFlagBitsKHRGetStrings(static_cast<VkVideoEncodeH264CapabilityFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeH264CapabilityFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeH264CapabilityFlagBitsKHR value) {
+    auto strings = VkVideoEncodeH264CapabilityFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeH264StdFlagBitsKHRGetStrings(VkVideoEncodeH264StdFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeH264StdFlagsKHR(Printer &p, std::string name, VkVideoEncodeH264StdFlagsKHR value) {
+    if (static_cast<VkVideoEncodeH264StdFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeH264StdFlagBitsKHRGetStrings(static_cast<VkVideoEncodeH264StdFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeH264StdFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeH264StdFlagBitsKHR value) {
+    auto strings = VkVideoEncodeH264StdFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeH265CapabilityFlagBitsKHRGetStrings(VkVideoEncodeH265CapabilityFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeH265CapabilityFlagsKHR(Printer &p, std::string name, VkVideoEncodeH265CapabilityFlagsKHR value) {
+    if (static_cast<VkVideoEncodeH265CapabilityFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeH265CapabilityFlagBitsKHRGetStrings(static_cast<VkVideoEncodeH265CapabilityFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeH265CapabilityFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeH265CapabilityFlagBitsKHR value) {
+    auto strings = VkVideoEncodeH265CapabilityFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeH265CtbSizeFlagBitsKHRGetStrings(VkVideoEncodeH265CtbSizeFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeH265CtbSizeFlagsKHR(Printer &p, std::string name, VkVideoEncodeH265CtbSizeFlagsKHR value) {
+    if (static_cast<VkVideoEncodeH265CtbSizeFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeH265CtbSizeFlagBitsKHRGetStrings(static_cast<VkVideoEncodeH265CtbSizeFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeH265CtbSizeFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeH265CtbSizeFlagBitsKHR value) {
+    auto strings = VkVideoEncodeH265CtbSizeFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeH265StdFlagBitsKHRGetStrings(VkVideoEncodeH265StdFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeH265StdFlagsKHR(Printer &p, std::string name, VkVideoEncodeH265StdFlagsKHR value) {
+    if (static_cast<VkVideoEncodeH265StdFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeH265StdFlagBitsKHRGetStrings(static_cast<VkVideoEncodeH265StdFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeH265StdFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeH265StdFlagBitsKHR value) {
+    auto strings = VkVideoEncodeH265StdFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeH265TransformBlockSizeFlagBitsKHRGetStrings(
+    VkVideoEncodeH265TransformBlockSizeFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR");
+    if (VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeH265TransformBlockSizeFlagsKHR(Printer &p, std::string name,
+                                                     VkVideoEncodeH265TransformBlockSizeFlagsKHR value) {
+    if (static_cast<VkVideoEncodeH265TransformBlockSizeFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeH265TransformBlockSizeFlagBitsKHRGetStrings(
+        static_cast<VkVideoEncodeH265TransformBlockSizeFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeH265TransformBlockSizeFlagBitsKHR(Printer &p, std::string name,
+                                                        VkVideoEncodeH265TransformBlockSizeFlagBitsKHR value) {
+    auto strings = VkVideoEncodeH265TransformBlockSizeFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeIntraRefreshModeFlagBitsKHRGetStrings(VkVideoEncodeIntraRefreshModeFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("VIDEO_ENCODE_INTRA_REFRESH_MODE_NONE_KHR");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_PER_PICTURE_PARTITION_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_INTRA_REFRESH_MODE_PER_PICTURE_PARTITION_BIT_KHR");
+    if (VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_BASED_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_BASED_BIT_KHR");
+    if (VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_ROW_BASED_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_ROW_BASED_BIT_KHR");
+    if (VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_COLUMN_BASED_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_COLUMN_BASED_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeIntraRefreshModeFlagsKHR(Printer &p, std::string name, VkVideoEncodeIntraRefreshModeFlagsKHR value) {
+    if (static_cast<VkVideoEncodeIntraRefreshModeFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeIntraRefreshModeFlagBitsKHRGetStrings(static_cast<VkVideoEncodeIntraRefreshModeFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeIntraRefreshModeFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeIntraRefreshModeFlagBitsKHR value) {
+    auto strings = VkVideoEncodeIntraRefreshModeFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeRateControlModeFlagBitsKHRGetStrings(VkVideoEncodeRateControlModeFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR & value)
+        strings.push_back("VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR");
+    if (VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR");
+    if (VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeRateControlModeFlagsKHR(Printer &p, std::string name, VkVideoEncodeRateControlModeFlagsKHR value) {
+    if (static_cast<VkVideoEncodeRateControlModeFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeRateControlModeFlagBitsKHRGetStrings(static_cast<VkVideoEncodeRateControlModeFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeRateControlModeFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeRateControlModeFlagBitsKHR value) {
+    auto strings = VkVideoEncodeRateControlModeFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeRgbChromaOffsetFlagBitsVALVEGetStrings(VkVideoEncodeRgbChromaOffsetFlagBitsVALVE value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE & value)
+        strings.push_back("VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE");
+    if (VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE & value)
+        strings.push_back("VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE");
+    return strings;
+}
+void DumpVkVideoEncodeRgbChromaOffsetFlagsVALVE(Printer &p, std::string name, VkVideoEncodeRgbChromaOffsetFlagsVALVE value) {
+    if (static_cast<VkVideoEncodeRgbChromaOffsetFlagBitsVALVE>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings =
+        VkVideoEncodeRgbChromaOffsetFlagBitsVALVEGetStrings(static_cast<VkVideoEncodeRgbChromaOffsetFlagBitsVALVE>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeRgbChromaOffsetFlagBitsVALVE(Printer &p, std::string name, VkVideoEncodeRgbChromaOffsetFlagBitsVALVE value) {
+    auto strings = VkVideoEncodeRgbChromaOffsetFlagBitsVALVEGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeRgbModelConversionFlagBitsVALVEGetStrings(
+    VkVideoEncodeRgbModelConversionFlagBitsVALVE value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE & value)
+        strings.push_back("VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE");
+    if (VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE & value)
+        strings.push_back("VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE");
+    if (VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE & value)
+        strings.push_back("VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE");
+    if (VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE & value)
+        strings.push_back("VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE");
+    if (VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE & value)
+        strings.push_back("VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE");
+    return strings;
+}
+void DumpVkVideoEncodeRgbModelConversionFlagsVALVE(Printer &p, std::string name, VkVideoEncodeRgbModelConversionFlagsVALVE value) {
+    if (static_cast<VkVideoEncodeRgbModelConversionFlagBitsVALVE>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings =
+        VkVideoEncodeRgbModelConversionFlagBitsVALVEGetStrings(static_cast<VkVideoEncodeRgbModelConversionFlagBitsVALVE>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeRgbModelConversionFlagBitsVALVE(Printer &p, std::string name,
+                                                      VkVideoEncodeRgbModelConversionFlagBitsVALVE value) {
+    auto strings = VkVideoEncodeRgbModelConversionFlagBitsVALVEGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeRgbRangeCompressionFlagBitsVALVEGetStrings(
+    VkVideoEncodeRgbRangeCompressionFlagBitsVALVE value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("None");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE & value)
+        strings.push_back("VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE");
+    if (VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE & value)
+        strings.push_back("VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE");
+    return strings;
+}
+void DumpVkVideoEncodeRgbRangeCompressionFlagsVALVE(Printer &p, std::string name,
+                                                    VkVideoEncodeRgbRangeCompressionFlagsVALVE value) {
+    if (static_cast<VkVideoEncodeRgbRangeCompressionFlagBitsVALVE>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings =
+        VkVideoEncodeRgbRangeCompressionFlagBitsVALVEGetStrings(static_cast<VkVideoEncodeRgbRangeCompressionFlagBitsVALVE>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeRgbRangeCompressionFlagBitsVALVE(Printer &p, std::string name,
+                                                       VkVideoEncodeRgbRangeCompressionFlagBitsVALVE value) {
+    auto strings = VkVideoEncodeRgbRangeCompressionFlagBitsVALVEGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+std::vector<const char *> VkVideoEncodeUsageFlagBitsKHRGetStrings(VkVideoEncodeUsageFlagBitsKHR value) {
+    std::vector<const char *> strings;
+    if (value == 0) {
+        strings.push_back("VIDEO_ENCODE_USAGE_DEFAULT_KHR");
+        return strings;
+    }
+    if (VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR");
+    if (VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR");
+    if (VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR");
+    if (VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR & value) strings.push_back("VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR");
+    return strings;
+}
+void DumpVkVideoEncodeUsageFlagsKHR(Printer &p, std::string name, VkVideoEncodeUsageFlagsKHR value) {
+    if (static_cast<VkVideoEncodeUsageFlagBitsKHR>(value) == 0) {
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output) p.SetAsType().PrintString("None");
+        return;
+    }
+    auto strings = VkVideoEncodeUsageFlagBitsKHRGetStrings(static_cast<VkVideoEncodeUsageFlagBitsKHR>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for (auto &str : strings) {
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }
+}
+void DumpVkVideoEncodeUsageFlagBitsKHR(Printer &p, std::string name, VkVideoEncodeUsageFlagBitsKHR value) {
+    auto strings = VkVideoEncodeUsageFlagBitsKHRGetStrings(value);
+    if (strings.size() > 0) {
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }
+}
+
+void DumpVkComponentMapping(Printer &p, std::string name, const VkComponentMapping &obj);
+void DumpVkConformanceVersion(Printer &p, std::string name, const VkConformanceVersion &obj);
+void DumpVkCooperativeMatrixPropertiesKHR(Printer &p, std::string name, const VkCooperativeMatrixPropertiesKHR &obj);
+void DumpVkDisplayModeParametersKHR(Printer &p, std::string name, const VkDisplayModeParametersKHR &obj);
+void DumpVkDisplayModePropertiesKHR(Printer &p, std::string name, const VkDisplayModePropertiesKHR &obj);
+void DumpVkDisplayPlaneCapabilitiesKHR(Printer &p, std::string name, const VkDisplayPlaneCapabilitiesKHR &obj);
+void DumpVkDisplayPlanePropertiesKHR(Printer &p, std::string name, const VkDisplayPlanePropertiesKHR &obj);
+void DumpVkDisplayPropertiesKHR(Printer &p, std::string name, const VkDisplayPropertiesKHR &obj);
+void DumpVkDrmFormatModifierProperties2EXT(Printer &p, std::string name, const VkDrmFormatModifierProperties2EXT &obj);
+void DumpVkExtensionProperties(Printer &p, std::string name, const VkExtensionProperties &obj);
+void DumpVkExtent2D(Printer &p, std::string name, const VkExtent2D &obj);
+void DumpVkExtent3D(Printer &p, std::string name, const VkExtent3D &obj);
+void DumpVkFormatProperties(Printer &p, std::string name, const VkFormatProperties &obj);
+void DumpVkFormatProperties3(Printer &p, std::string name, const VkFormatProperties3 &obj);
+void DumpVkLayerProperties(Printer &p, std::string name, const VkLayerProperties &obj);
+void DumpVkMultisamplePropertiesEXT(Printer &p, std::string name, const VkMultisamplePropertiesEXT &obj);
+void DumpVkOffset2D(Printer &p, std::string name, const VkOffset2D &obj);
+void DumpVkPhysicalDevice16BitStorageFeatures(Printer &p, std::string name, const VkPhysicalDevice16BitStorageFeatures &obj);
+void DumpVkPhysicalDevice4444FormatsFeaturesEXT(Printer &p, std::string name, const VkPhysicalDevice4444FormatsFeaturesEXT &obj);
+void DumpVkPhysicalDevice8BitStorageFeatures(Printer &p, std::string name, const VkPhysicalDevice8BitStorageFeatures &obj);
+void DumpVkPhysicalDeviceASTCDecodeFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceASTCDecodeFeaturesEXT &obj);
+void DumpVkPhysicalDeviceAccelerationStructureFeaturesKHR(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceAccelerationStructureFeaturesKHR &obj);
+void DumpVkPhysicalDeviceAccelerationStructurePropertiesKHR(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceAccelerationStructurePropertiesKHR &obj);
+void DumpVkPhysicalDeviceAddressBindingReportFeaturesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceAddressBindingReportFeaturesEXT &obj);
+void DumpVkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT &obj);
+void DumpVkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT &obj);
+void DumpVkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT &obj);
+void DumpVkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT &obj);
+void DumpVkPhysicalDeviceBorderColorSwizzleFeaturesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT &obj);
+void DumpVkPhysicalDeviceBufferDeviceAddressFeatures(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceBufferDeviceAddressFeatures &obj);
+void DumpVkPhysicalDeviceBufferDeviceAddressFeaturesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT &obj);
+void DumpVkPhysicalDeviceColorWriteEnableFeaturesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceColorWriteEnableFeaturesEXT &obj);
+void DumpVkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR &obj);
+void DumpVkPhysicalDeviceComputeShaderDerivativesPropertiesKHR(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR &obj);
+void DumpVkPhysicalDeviceConditionalRenderingFeaturesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceConditionalRenderingFeaturesEXT &obj);
+void DumpVkPhysicalDeviceConservativeRasterizationPropertiesEXT(Printer &p, std::string name,
+                                                                const VkPhysicalDeviceConservativeRasterizationPropertiesEXT &obj);
+void DumpVkPhysicalDeviceCooperativeMatrixFeaturesKHR(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceCooperativeMatrixFeaturesKHR &obj);
+void DumpVkPhysicalDeviceCooperativeMatrixPropertiesKHR(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceCooperativeMatrixPropertiesKHR &obj);
+void DumpVkPhysicalDeviceCopyMemoryIndirectFeaturesKHR(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR &obj);
+void DumpVkPhysicalDeviceCopyMemoryIndirectPropertiesKHR(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR &obj);
+void DumpVkPhysicalDeviceCustomBorderColorFeaturesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceCustomBorderColorFeaturesEXT &obj);
+void DumpVkPhysicalDeviceCustomBorderColorPropertiesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceCustomBorderColorPropertiesEXT &obj);
+void DumpVkPhysicalDeviceCustomResolveFeaturesEXT(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceCustomResolveFeaturesEXT &obj);
+void DumpVkPhysicalDeviceDepthBiasControlFeaturesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceDepthBiasControlFeaturesEXT &obj);
+void DumpVkPhysicalDeviceDepthClampControlFeaturesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceDepthClampControlFeaturesEXT &obj);
+void DumpVkPhysicalDeviceDepthClampZeroOneFeaturesKHR(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR &obj);
+void DumpVkPhysicalDeviceDepthClipControlFeaturesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceDepthClipControlFeaturesEXT &obj);
+void DumpVkPhysicalDeviceDepthClipEnableFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceDepthClipEnableFeaturesEXT &obj);
+void DumpVkPhysicalDeviceDepthStencilResolveProperties(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceDepthStencilResolveProperties &obj);
+void DumpVkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT &obj);
+void DumpVkPhysicalDeviceDescriptorBufferFeaturesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceDescriptorBufferFeaturesEXT &obj);
+void DumpVkPhysicalDeviceDescriptorBufferPropertiesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceDescriptorBufferPropertiesEXT &obj);
+void DumpVkPhysicalDeviceDescriptorHeapFeaturesEXT(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceDescriptorHeapFeaturesEXT &obj);
+void DumpVkPhysicalDeviceDescriptorHeapPropertiesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceDescriptorHeapPropertiesEXT &obj);
+void DumpVkPhysicalDeviceDescriptorHeapTensorPropertiesARM(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceDescriptorHeapTensorPropertiesARM &obj);
+void DumpVkPhysicalDeviceDescriptorIndexingFeatures(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceDescriptorIndexingFeatures &obj);
+void DumpVkPhysicalDeviceDescriptorIndexingProperties(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceDescriptorIndexingProperties &obj);
+void DumpVkPhysicalDeviceDeviceAddressCommandsFeaturesKHR(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR &obj);
+void DumpVkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT &obj);
+void DumpVkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(Printer &p, std::string name,
+                                                              const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT &obj);
+void DumpVkPhysicalDeviceDeviceMemoryReportFeaturesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT &obj);
+void DumpVkPhysicalDeviceDiscardRectanglePropertiesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceDiscardRectanglePropertiesEXT &obj);
+void DumpVkPhysicalDeviceDriverProperties(Printer &p, std::string name, const VkPhysicalDeviceDriverProperties &obj);
+void DumpVkPhysicalDeviceDrmPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceDrmPropertiesEXT &obj);
+void DumpVkPhysicalDeviceDynamicRenderingFeatures(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceDynamicRenderingFeatures &obj);
+void DumpVkPhysicalDeviceDynamicRenderingLocalReadFeatures(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceDynamicRenderingLocalReadFeatures &obj);
+void DumpVkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT &obj);
+void DumpVkPhysicalDeviceExtendedDynamicState2FeaturesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT &obj);
+void DumpVkPhysicalDeviceExtendedDynamicState3FeaturesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT &obj);
+void DumpVkPhysicalDeviceExtendedDynamicState3PropertiesEXT(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT &obj);
+void DumpVkPhysicalDeviceExtendedDynamicStateFeaturesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT &obj);
+void DumpVkPhysicalDeviceExternalMemoryHostPropertiesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceExternalMemoryHostPropertiesEXT &obj);
+void DumpVkPhysicalDeviceFaultFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceFaultFeaturesEXT &obj);
+void DumpVkPhysicalDeviceFaultFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceFaultFeaturesKHR &obj);
+void DumpVkPhysicalDeviceFaultPropertiesKHR(Printer &p, std::string name, const VkPhysicalDeviceFaultPropertiesKHR &obj);
+void DumpVkPhysicalDeviceFeatures(Printer &p, std::string name, const VkPhysicalDeviceFeatures &obj);
+void DumpVkPhysicalDeviceFloatControlsProperties(Printer &p, std::string name, const VkPhysicalDeviceFloatControlsProperties &obj);
+void DumpVkPhysicalDeviceFragmentDensityMap2FeaturesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT &obj);
+void DumpVkPhysicalDeviceFragmentDensityMap2PropertiesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT &obj);
+void DumpVkPhysicalDeviceFragmentDensityMapFeaturesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceFragmentDensityMapFeaturesEXT &obj);
+void DumpVkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT &obj);
+void DumpVkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT &obj);
+void DumpVkPhysicalDeviceFragmentDensityMapPropertiesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceFragmentDensityMapPropertiesEXT &obj);
+void DumpVkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(Printer &p, std::string name,
+                                                              const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR &obj);
+void DumpVkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(Printer &p, std::string name,
+                                                                const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR &obj);
+void DumpVkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT &obj);
+void DumpVkPhysicalDeviceFragmentShadingRateFeaturesKHR(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceFragmentShadingRateFeaturesKHR &obj);
+void DumpVkPhysicalDeviceFragmentShadingRateKHR(Printer &p, std::string name, const VkPhysicalDeviceFragmentShadingRateKHR &obj);
+void DumpVkPhysicalDeviceFragmentShadingRatePropertiesKHR(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceFragmentShadingRatePropertiesKHR &obj);
+void DumpVkPhysicalDeviceFrameBoundaryFeaturesEXT(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceFrameBoundaryFeaturesEXT &obj);
+void DumpVkPhysicalDeviceGlobalPriorityQueryFeatures(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceGlobalPriorityQueryFeatures &obj);
+void DumpVkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT &obj);
+void DumpVkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(Printer &p, std::string name,
+                                                              const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT &obj);
+void DumpVkPhysicalDeviceHostImageCopyFeatures(Printer &p, std::string name, const VkPhysicalDeviceHostImageCopyFeatures &obj);
+void DumpVkPhysicalDeviceHostImageCopyProperties(Printer &p, std::string name, const VkPhysicalDeviceHostImageCopyProperties &obj);
+void DumpVkPhysicalDeviceHostQueryResetFeatures(Printer &p, std::string name, const VkPhysicalDeviceHostQueryResetFeatures &obj);
+void DumpVkPhysicalDeviceIDProperties(Printer &p, std::string name, const VkPhysicalDeviceIDProperties &obj);
+void DumpVkPhysicalDeviceImage2DViewOf3DFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT &obj);
+void DumpVkPhysicalDeviceImageCompressionControlFeaturesEXT(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceImageCompressionControlFeaturesEXT &obj);
+void DumpVkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT &obj);
+void DumpVkPhysicalDeviceImageRobustnessFeatures(Printer &p, std::string name, const VkPhysicalDeviceImageRobustnessFeatures &obj);
+void DumpVkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT &obj);
+void DumpVkPhysicalDeviceImageViewMinLodFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceImageViewMinLodFeaturesEXT &obj);
+void DumpVkPhysicalDeviceImagelessFramebufferFeatures(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceImagelessFramebufferFeatures &obj);
+void DumpVkPhysicalDeviceIndexTypeUint8Features(Printer &p, std::string name, const VkPhysicalDeviceIndexTypeUint8Features &obj);
+void DumpVkPhysicalDeviceInlineUniformBlockFeatures(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceInlineUniformBlockFeatures &obj);
+void DumpVkPhysicalDeviceInlineUniformBlockProperties(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceInlineUniformBlockProperties &obj);
+void DumpVkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR(
+    Printer &p, std::string name, const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR &obj);
+void DumpVkPhysicalDeviceLayeredApiPropertiesKHR(Printer &p, std::string name, const VkPhysicalDeviceLayeredApiPropertiesKHR &obj);
+void DumpVkPhysicalDeviceLayeredApiPropertiesListKHR(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceLayeredApiPropertiesListKHR &obj);
+void DumpVkPhysicalDeviceLegacyDitheringFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceLegacyDitheringFeaturesEXT &obj);
+void DumpVkPhysicalDeviceLegacyVertexAttributesFeaturesEXT(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT &obj);
+void DumpVkPhysicalDeviceLegacyVertexAttributesPropertiesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT &obj);
+void DumpVkPhysicalDeviceLimits(Printer &p, std::string name, const VkPhysicalDeviceLimits &obj);
+void DumpVkPhysicalDeviceLineRasterizationFeatures(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceLineRasterizationFeatures &obj);
+void DumpVkPhysicalDeviceLineRasterizationProperties(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceLineRasterizationProperties &obj);
+void DumpVkPhysicalDeviceMaintenance10FeaturesKHR(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceMaintenance10FeaturesKHR &obj);
+void DumpVkPhysicalDeviceMaintenance10PropertiesKHR(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceMaintenance10PropertiesKHR &obj);
+void DumpVkPhysicalDeviceMaintenance3Properties(Printer &p, std::string name, const VkPhysicalDeviceMaintenance3Properties &obj);
+void DumpVkPhysicalDeviceMaintenance4Features(Printer &p, std::string name, const VkPhysicalDeviceMaintenance4Features &obj);
+void DumpVkPhysicalDeviceMaintenance4Properties(Printer &p, std::string name, const VkPhysicalDeviceMaintenance4Properties &obj);
+void DumpVkPhysicalDeviceMaintenance5Features(Printer &p, std::string name, const VkPhysicalDeviceMaintenance5Features &obj);
+void DumpVkPhysicalDeviceMaintenance5Properties(Printer &p, std::string name, const VkPhysicalDeviceMaintenance5Properties &obj);
+void DumpVkPhysicalDeviceMaintenance6Features(Printer &p, std::string name, const VkPhysicalDeviceMaintenance6Features &obj);
+void DumpVkPhysicalDeviceMaintenance6Properties(Printer &p, std::string name, const VkPhysicalDeviceMaintenance6Properties &obj);
+void DumpVkPhysicalDeviceMaintenance7FeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceMaintenance7FeaturesKHR &obj);
+void DumpVkPhysicalDeviceMaintenance7PropertiesKHR(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceMaintenance7PropertiesKHR &obj);
+void DumpVkPhysicalDeviceMaintenance8FeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceMaintenance8FeaturesKHR &obj);
+void DumpVkPhysicalDeviceMaintenance9FeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceMaintenance9FeaturesKHR &obj);
+void DumpVkPhysicalDeviceMaintenance9PropertiesKHR(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceMaintenance9PropertiesKHR &obj);
+void DumpVkPhysicalDeviceMapMemoryPlacedFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT &obj);
+void DumpVkPhysicalDeviceMapMemoryPlacedPropertiesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT &obj);
+void DumpVkPhysicalDeviceMemoryBudgetPropertiesEXT(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceMemoryBudgetPropertiesEXT &obj);
+void DumpVkPhysicalDeviceMemoryDecompressionFeaturesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceMemoryDecompressionFeaturesEXT &obj);
+void DumpVkPhysicalDeviceMemoryDecompressionPropertiesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceMemoryDecompressionPropertiesEXT &obj);
+void DumpVkPhysicalDeviceMemoryPriorityFeaturesEXT(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceMemoryPriorityFeaturesEXT &obj);
+void DumpVkPhysicalDeviceMeshShaderFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceMeshShaderFeaturesEXT &obj);
+void DumpVkPhysicalDeviceMeshShaderPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceMeshShaderPropertiesEXT &obj);
+void DumpVkPhysicalDeviceMultiDrawFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceMultiDrawFeaturesEXT &obj);
+void DumpVkPhysicalDeviceMultiDrawPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceMultiDrawPropertiesEXT &obj);
+void DumpVkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT &obj);
+void DumpVkPhysicalDeviceMultiviewFeatures(Printer &p, std::string name, const VkPhysicalDeviceMultiviewFeatures &obj);
+void DumpVkPhysicalDeviceMultiviewProperties(Printer &p, std::string name, const VkPhysicalDeviceMultiviewProperties &obj);
+void DumpVkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT &obj);
+void DumpVkPhysicalDeviceNestedCommandBufferFeaturesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceNestedCommandBufferFeaturesEXT &obj);
+void DumpVkPhysicalDeviceNestedCommandBufferPropertiesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceNestedCommandBufferPropertiesEXT &obj);
+void DumpVkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT &obj);
+void DumpVkPhysicalDeviceOpacityMicromapFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceOpacityMicromapFeaturesEXT &obj);
+void DumpVkPhysicalDeviceOpacityMicromapPropertiesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceOpacityMicromapPropertiesEXT &obj);
+void DumpVkPhysicalDevicePCIBusInfoPropertiesEXT(Printer &p, std::string name, const VkPhysicalDevicePCIBusInfoPropertiesEXT &obj);
+void DumpVkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(Printer &p, std::string name,
+                                                              const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT &obj);
+void DumpVkPhysicalDevicePerformanceQueryFeaturesKHR(Printer &p, std::string name,
+                                                     const VkPhysicalDevicePerformanceQueryFeaturesKHR &obj);
+void DumpVkPhysicalDevicePerformanceQueryPropertiesKHR(Printer &p, std::string name,
+                                                       const VkPhysicalDevicePerformanceQueryPropertiesKHR &obj);
+void DumpVkPhysicalDevicePipelineBinaryFeaturesKHR(Printer &p, std::string name,
+                                                   const VkPhysicalDevicePipelineBinaryFeaturesKHR &obj);
+void DumpVkPhysicalDevicePipelineBinaryPropertiesKHR(Printer &p, std::string name,
+                                                     const VkPhysicalDevicePipelineBinaryPropertiesKHR &obj);
+void DumpVkPhysicalDevicePipelineCreationCacheControlFeatures(Printer &p, std::string name,
+                                                              const VkPhysicalDevicePipelineCreationCacheControlFeatures &obj);
+void DumpVkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
+    Printer &p, std::string name, const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR &obj);
+void DumpVkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(Printer &p, std::string name,
+                                                                const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT &obj);
+void DumpVkPhysicalDevicePipelinePropertiesFeaturesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDevicePipelinePropertiesFeaturesEXT &obj);
+void DumpVkPhysicalDevicePipelineProtectedAccessFeatures(Printer &p, std::string name,
+                                                         const VkPhysicalDevicePipelineProtectedAccessFeatures &obj);
+void DumpVkPhysicalDevicePipelineRobustnessFeatures(Printer &p, std::string name,
+                                                    const VkPhysicalDevicePipelineRobustnessFeatures &obj);
+void DumpVkPhysicalDevicePipelineRobustnessProperties(Printer &p, std::string name,
+                                                      const VkPhysicalDevicePipelineRobustnessProperties &obj);
+void DumpVkPhysicalDevicePointClippingProperties(Printer &p, std::string name, const VkPhysicalDevicePointClippingProperties &obj);
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+void DumpVkPhysicalDevicePortabilitySubsetFeaturesKHR(Printer &p, std::string name,
+                                                      const VkPhysicalDevicePortabilitySubsetFeaturesKHR &obj);
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+void DumpVkPhysicalDevicePortabilitySubsetPropertiesKHR(Printer &p, std::string name,
+                                                        const VkPhysicalDevicePortabilitySubsetPropertiesKHR &obj);
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+void DumpVkPhysicalDevicePresentId2FeaturesKHR(Printer &p, std::string name, const VkPhysicalDevicePresentId2FeaturesKHR &obj);
+void DumpVkPhysicalDevicePresentIdFeaturesKHR(Printer &p, std::string name, const VkPhysicalDevicePresentIdFeaturesKHR &obj);
+void DumpVkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR(Printer &p, std::string name,
+                                                               const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR &obj);
+void DumpVkPhysicalDevicePresentTimingFeaturesEXT(Printer &p, std::string name,
+                                                  const VkPhysicalDevicePresentTimingFeaturesEXT &obj);
+void DumpVkPhysicalDevicePresentWait2FeaturesKHR(Printer &p, std::string name, const VkPhysicalDevicePresentWait2FeaturesKHR &obj);
+void DumpVkPhysicalDevicePresentWaitFeaturesKHR(Printer &p, std::string name, const VkPhysicalDevicePresentWaitFeaturesKHR &obj);
+void DumpVkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT &obj);
+void DumpVkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT &obj);
+void DumpVkPhysicalDevicePrivateDataFeatures(Printer &p, std::string name, const VkPhysicalDevicePrivateDataFeatures &obj);
+void DumpVkPhysicalDeviceProtectedMemoryFeatures(Printer &p, std::string name, const VkPhysicalDeviceProtectedMemoryFeatures &obj);
+void DumpVkPhysicalDeviceProtectedMemoryProperties(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceProtectedMemoryProperties &obj);
+void DumpVkPhysicalDeviceProvokingVertexFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceProvokingVertexFeaturesEXT &obj);
+void DumpVkPhysicalDeviceProvokingVertexPropertiesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceProvokingVertexPropertiesEXT &obj);
+void DumpVkPhysicalDevicePushDescriptorProperties(Printer &p, std::string name,
+                                                  const VkPhysicalDevicePushDescriptorProperties &obj);
+void DumpVkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT &obj);
+void DumpVkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT &obj);
+void DumpVkPhysicalDeviceRayQueryFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceRayQueryFeaturesKHR &obj);
+void DumpVkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT(Printer &p, std::string name,
+                                                                const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT &obj);
+void DumpVkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT &obj);
+void DumpVkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR &obj);
+void DumpVkPhysicalDeviceRayTracingPipelineFeaturesKHR(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceRayTracingPipelineFeaturesKHR &obj);
+void DumpVkPhysicalDeviceRayTracingPipelinePropertiesKHR(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceRayTracingPipelinePropertiesKHR &obj);
+void DumpVkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR &obj);
+void DumpVkPhysicalDeviceRobustness2FeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceRobustness2FeaturesKHR &obj);
+void DumpVkPhysicalDeviceRobustness2PropertiesKHR(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceRobustness2PropertiesKHR &obj);
+void DumpVkPhysicalDeviceSampleLocationsPropertiesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceSampleLocationsPropertiesEXT &obj);
+void DumpVkPhysicalDeviceSamplerFilterMinmaxProperties(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceSamplerFilterMinmaxProperties &obj);
+void DumpVkPhysicalDeviceSamplerYcbcrConversionFeatures(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceSamplerYcbcrConversionFeatures &obj);
+void DumpVkPhysicalDeviceScalarBlockLayoutFeatures(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceScalarBlockLayoutFeatures &obj);
+void DumpVkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures &obj);
+void DumpVkPhysicalDeviceShader64BitIndexingFeaturesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceShader64BitIndexingFeaturesEXT &obj);
+void DumpVkPhysicalDeviceShaderAbortFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceShaderAbortFeaturesKHR &obj);
+void DumpVkPhysicalDeviceShaderAbortPropertiesKHR(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceShaderAbortPropertiesKHR &obj);
+void DumpVkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT &obj);
+void DumpVkPhysicalDeviceShaderAtomicFloatFeaturesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT &obj);
+void DumpVkPhysicalDeviceShaderAtomicInt64Features(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceShaderAtomicInt64Features &obj);
+void DumpVkPhysicalDeviceShaderBfloat16FeaturesKHR(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceShaderBfloat16FeaturesKHR &obj);
+void DumpVkPhysicalDeviceShaderClockFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceShaderClockFeaturesKHR &obj);
+void DumpVkPhysicalDeviceShaderConstantDataFeaturesKHR(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceShaderConstantDataFeaturesKHR &obj);
+void DumpVkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(Printer &p, std::string name,
+                                                                const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures &obj);
+void DumpVkPhysicalDeviceShaderDrawParametersFeatures(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceShaderDrawParametersFeatures &obj);
+void DumpVkPhysicalDeviceShaderExpectAssumeFeatures(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceShaderExpectAssumeFeatures &obj);
+void DumpVkPhysicalDeviceShaderFloat16Int8Features(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceShaderFloat16Int8Features &obj);
+void DumpVkPhysicalDeviceShaderFloat8FeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceShaderFloat8FeaturesEXT &obj);
+void DumpVkPhysicalDeviceShaderFloatControls2Features(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceShaderFloatControls2Features &obj);
+void DumpVkPhysicalDeviceShaderFmaFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceShaderFmaFeaturesKHR &obj);
+void DumpVkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT &obj);
+void DumpVkPhysicalDeviceShaderIntegerDotProductFeatures(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceShaderIntegerDotProductFeatures &obj);
+void DumpVkPhysicalDeviceShaderIntegerDotProductProperties(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceShaderIntegerDotProductProperties &obj);
+void DumpVkPhysicalDeviceShaderLongVectorFeaturesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceShaderLongVectorFeaturesEXT &obj);
+void DumpVkPhysicalDeviceShaderLongVectorPropertiesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceShaderLongVectorPropertiesEXT &obj);
+void DumpVkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR &obj);
+void DumpVkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT &obj);
+void DumpVkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT &obj);
+void DumpVkPhysicalDeviceShaderObjectFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceShaderObjectFeaturesEXT &obj);
+void DumpVkPhysicalDeviceShaderObjectPropertiesEXT(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceShaderObjectPropertiesEXT &obj);
+void DumpVkPhysicalDeviceShaderQuadControlFeaturesKHR(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceShaderQuadControlFeaturesKHR &obj);
+void DumpVkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(
+    Printer &p, std::string name, const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR &obj);
+void DumpVkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT &obj);
+void DumpVkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures &obj);
+void DumpVkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT(Printer &p, std::string name,
+                                                              const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT &obj);
+void DumpVkPhysicalDeviceShaderSubgroupRotateFeatures(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceShaderSubgroupRotateFeatures &obj);
+void DumpVkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
+    Printer &p, std::string name, const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR &obj);
+void DumpVkPhysicalDeviceShaderTerminateInvocationFeatures(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceShaderTerminateInvocationFeatures &obj);
+void DumpVkPhysicalDeviceShaderTileImageFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceShaderTileImageFeaturesEXT &obj);
+void DumpVkPhysicalDeviceShaderTileImagePropertiesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceShaderTileImagePropertiesEXT &obj);
+void DumpVkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT &obj);
+void DumpVkPhysicalDeviceShaderUntypedPointersFeaturesKHR(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR &obj);
+void DumpVkPhysicalDeviceSparseProperties(Printer &p, std::string name, const VkPhysicalDeviceSparseProperties &obj);
+void DumpVkPhysicalDeviceSubgroupProperties(Printer &p, std::string name, const VkPhysicalDeviceSubgroupProperties &obj);
+void DumpVkPhysicalDeviceSubgroupSizeControlFeatures(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceSubgroupSizeControlFeatures &obj);
+void DumpVkPhysicalDeviceSubgroupSizeControlProperties(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceSubgroupSizeControlProperties &obj);
+void DumpVkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT &obj);
+void DumpVkPhysicalDeviceSwapchainMaintenance1FeaturesKHR(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR &obj);
+void DumpVkPhysicalDeviceSynchronization2Features(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceSynchronization2Features &obj);
+void DumpVkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT &obj);
+void DumpVkPhysicalDeviceTexelBufferAlignmentProperties(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceTexelBufferAlignmentProperties &obj);
+void DumpVkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT &obj);
+void DumpVkPhysicalDeviceTextureCompressionASTCHDRFeatures(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceTextureCompressionASTCHDRFeatures &obj);
+void DumpVkPhysicalDeviceTimelineSemaphoreFeatures(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceTimelineSemaphoreFeatures &obj);
+void DumpVkPhysicalDeviceTimelineSemaphoreProperties(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceTimelineSemaphoreProperties &obj);
+void DumpVkPhysicalDeviceToolProperties(Printer &p, std::string name, const VkPhysicalDeviceToolProperties &obj);
+void DumpVkPhysicalDeviceTransformFeedbackFeaturesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceTransformFeedbackFeaturesEXT &obj);
+void DumpVkPhysicalDeviceTransformFeedbackPropertiesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceTransformFeedbackPropertiesEXT &obj);
+void DumpVkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR &obj);
+void DumpVkPhysicalDeviceUniformBufferStandardLayoutFeatures(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures &obj);
+void DumpVkPhysicalDeviceVariablePointersFeatures(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceVariablePointersFeatures &obj);
+void DumpVkPhysicalDeviceVertexAttributeDivisorFeatures(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceVertexAttributeDivisorFeatures &obj);
+void DumpVkPhysicalDeviceVertexAttributeDivisorProperties(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceVertexAttributeDivisorProperties &obj);
+void DumpVkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT &obj);
+void DumpVkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(Printer &p, std::string name,
+                                                              const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT &obj);
+void DumpVkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT &obj);
+void DumpVkPhysicalDeviceVideoDecodeVP9FeaturesKHR(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR &obj);
+void DumpVkPhysicalDeviceVideoEncodeAV1FeaturesKHR(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR &obj);
+void DumpVkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR &obj);
+void DumpVkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR &obj);
+void DumpVkPhysicalDeviceVideoMaintenance1FeaturesKHR(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceVideoMaintenance1FeaturesKHR &obj);
+void DumpVkPhysicalDeviceVideoMaintenance2FeaturesKHR(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceVideoMaintenance2FeaturesKHR &obj);
+void DumpVkPhysicalDeviceVulkan11Features(Printer &p, std::string name, const VkPhysicalDeviceVulkan11Features &obj);
+void DumpVkPhysicalDeviceVulkan11Properties(Printer &p, std::string name, const VkPhysicalDeviceVulkan11Properties &obj);
+void DumpVkPhysicalDeviceVulkan12Features(Printer &p, std::string name, const VkPhysicalDeviceVulkan12Features &obj);
+void DumpVkPhysicalDeviceVulkan12Properties(Printer &p, std::string name, const VkPhysicalDeviceVulkan12Properties &obj);
+void DumpVkPhysicalDeviceVulkan13Features(Printer &p, std::string name, const VkPhysicalDeviceVulkan13Features &obj);
+void DumpVkPhysicalDeviceVulkan13Properties(Printer &p, std::string name, const VkPhysicalDeviceVulkan13Properties &obj);
+void DumpVkPhysicalDeviceVulkan14Features(Printer &p, std::string name, const VkPhysicalDeviceVulkan14Features &obj);
+void DumpVkPhysicalDeviceVulkan14Properties(Printer &p, std::string name, const VkPhysicalDeviceVulkan14Properties &obj);
+void DumpVkPhysicalDeviceVulkanMemoryModelFeatures(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceVulkanMemoryModelFeatures &obj);
+void DumpVkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
+    Printer &p, std::string name, const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR &obj);
+void DumpVkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT &obj);
+void DumpVkPhysicalDeviceYcbcrImageArraysFeaturesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT &obj);
+void DumpVkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT &obj);
+void DumpVkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures &obj);
+void DumpVkPresentTimingSurfaceCapabilitiesEXT(Printer &p, std::string name, const VkPresentTimingSurfaceCapabilitiesEXT &obj);
+void DumpVkQueueFamilyGlobalPriorityProperties(Printer &p, std::string name, const VkQueueFamilyGlobalPriorityProperties &obj);
+void DumpVkQueueFamilyOwnershipTransferPropertiesKHR(Printer &p, std::string name,
+                                                     const VkQueueFamilyOwnershipTransferPropertiesKHR &obj);
+void DumpVkQueueFamilyQueryResultStatusPropertiesKHR(Printer &p, std::string name,
+                                                     const VkQueueFamilyQueryResultStatusPropertiesKHR &obj);
+void DumpVkQueueFamilyVideoPropertiesKHR(Printer &p, std::string name, const VkQueueFamilyVideoPropertiesKHR &obj);
+void DumpVkSharedPresentSurfaceCapabilitiesKHR(Printer &p, std::string name, const VkSharedPresentSurfaceCapabilitiesKHR &obj);
+void DumpVkSubpassResolvePerformanceQueryEXT(Printer &p, std::string name, const VkSubpassResolvePerformanceQueryEXT &obj);
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+void DumpVkSurfaceCapabilitiesFullScreenExclusiveEXT(Printer &p, std::string name,
+                                                     const VkSurfaceCapabilitiesFullScreenExclusiveEXT &obj);
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+void DumpVkSurfaceCapabilitiesKHR(Printer &p, std::string name, const VkSurfaceCapabilitiesKHR &obj);
+void DumpVkSurfaceCapabilitiesPresentId2KHR(Printer &p, std::string name, const VkSurfaceCapabilitiesPresentId2KHR &obj);
+void DumpVkSurfaceCapabilitiesPresentWait2KHR(Printer &p, std::string name, const VkSurfaceCapabilitiesPresentWait2KHR &obj);
+void DumpVkSurfaceFormatKHR(Printer &p, std::string name, const VkSurfaceFormatKHR &obj);
+void DumpVkSurfacePresentModeCompatibilityKHR(Printer &p, std::string name, const VkSurfacePresentModeCompatibilityKHR &obj);
+void DumpVkSurfacePresentScalingCapabilitiesKHR(Printer &p, std::string name, const VkSurfacePresentScalingCapabilitiesKHR &obj);
+void DumpVkSurfaceProtectedCapabilitiesKHR(Printer &p, std::string name, const VkSurfaceProtectedCapabilitiesKHR &obj);
+void DumpVkVideoCapabilitiesKHR(Printer &p, std::string name, const VkVideoCapabilitiesKHR &obj);
+void DumpVkVideoDecodeAV1CapabilitiesKHR(Printer &p, std::string name, const VkVideoDecodeAV1CapabilitiesKHR &obj);
+void DumpVkVideoDecodeAV1ProfileInfoKHR(Printer &p, std::string name, const VkVideoDecodeAV1ProfileInfoKHR &obj);
+void DumpVkVideoDecodeCapabilitiesKHR(Printer &p, std::string name, const VkVideoDecodeCapabilitiesKHR &obj);
+void DumpVkVideoDecodeH264CapabilitiesKHR(Printer &p, std::string name, const VkVideoDecodeH264CapabilitiesKHR &obj);
+void DumpVkVideoDecodeH264ProfileInfoKHR(Printer &p, std::string name, const VkVideoDecodeH264ProfileInfoKHR &obj);
+void DumpVkVideoDecodeH265CapabilitiesKHR(Printer &p, std::string name, const VkVideoDecodeH265CapabilitiesKHR &obj);
+void DumpVkVideoDecodeH265ProfileInfoKHR(Printer &p, std::string name, const VkVideoDecodeH265ProfileInfoKHR &obj);
+void DumpVkVideoDecodeUsageInfoKHR(Printer &p, std::string name, const VkVideoDecodeUsageInfoKHR &obj);
+void DumpVkVideoDecodeVP9CapabilitiesKHR(Printer &p, std::string name, const VkVideoDecodeVP9CapabilitiesKHR &obj);
+void DumpVkVideoDecodeVP9ProfileInfoKHR(Printer &p, std::string name, const VkVideoDecodeVP9ProfileInfoKHR &obj);
+void DumpVkVideoEncodeAV1CapabilitiesKHR(Printer &p, std::string name, const VkVideoEncodeAV1CapabilitiesKHR &obj);
+void DumpVkVideoEncodeAV1ProfileInfoKHR(Printer &p, std::string name, const VkVideoEncodeAV1ProfileInfoKHR &obj);
+void DumpVkVideoEncodeAV1QuantizationMapCapabilitiesKHR(Printer &p, std::string name,
+                                                        const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR &obj);
+void DumpVkVideoEncodeCapabilitiesKHR(Printer &p, std::string name, const VkVideoEncodeCapabilitiesKHR &obj);
+void DumpVkVideoEncodeH264CapabilitiesKHR(Printer &p, std::string name, const VkVideoEncodeH264CapabilitiesKHR &obj);
+void DumpVkVideoEncodeH264ProfileInfoKHR(Printer &p, std::string name, const VkVideoEncodeH264ProfileInfoKHR &obj);
+void DumpVkVideoEncodeH264QuantizationMapCapabilitiesKHR(Printer &p, std::string name,
+                                                         const VkVideoEncodeH264QuantizationMapCapabilitiesKHR &obj);
+void DumpVkVideoEncodeH265CapabilitiesKHR(Printer &p, std::string name, const VkVideoEncodeH265CapabilitiesKHR &obj);
+void DumpVkVideoEncodeH265ProfileInfoKHR(Printer &p, std::string name, const VkVideoEncodeH265ProfileInfoKHR &obj);
+void DumpVkVideoEncodeH265QuantizationMapCapabilitiesKHR(Printer &p, std::string name,
+                                                         const VkVideoEncodeH265QuantizationMapCapabilitiesKHR &obj);
+void DumpVkVideoEncodeIntraRefreshCapabilitiesKHR(Printer &p, std::string name,
+                                                  const VkVideoEncodeIntraRefreshCapabilitiesKHR &obj);
+void DumpVkVideoEncodeProfileRgbConversionInfoVALVE(Printer &p, std::string name,
+                                                    const VkVideoEncodeProfileRgbConversionInfoVALVE &obj);
+void DumpVkVideoEncodeQuantizationMapCapabilitiesKHR(Printer &p, std::string name,
+                                                     const VkVideoEncodeQuantizationMapCapabilitiesKHR &obj);
+void DumpVkVideoEncodeRgbConversionCapabilitiesVALVE(Printer &p, std::string name,
+                                                     const VkVideoEncodeRgbConversionCapabilitiesVALVE &obj);
+void DumpVkVideoEncodeUsageInfoKHR(Printer &p, std::string name, const VkVideoEncodeUsageInfoKHR &obj);
+void DumpVkVideoFormatAV1QuantizationMapPropertiesKHR(Printer &p, std::string name,
+                                                      const VkVideoFormatAV1QuantizationMapPropertiesKHR &obj);
+void DumpVkVideoFormatH265QuantizationMapPropertiesKHR(Printer &p, std::string name,
+                                                       const VkVideoFormatH265QuantizationMapPropertiesKHR &obj);
+void DumpVkVideoFormatPropertiesKHR(Printer &p, std::string name, const VkVideoFormatPropertiesKHR &obj);
+void DumpVkVideoFormatQuantizationMapPropertiesKHR(Printer &p, std::string name,
+                                                   const VkVideoFormatQuantizationMapPropertiesKHR &obj);
+void DumpVkVideoProfileInfoKHR(Printer &p, std::string name, const VkVideoProfileInfoKHR &obj);
+void DumpVkComponentMapping(Printer &p, std::string name, const VkComponentMapping &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkComponentSwizzle(p, "r", obj.r);
+    DumpVkComponentSwizzle(p, "g", obj.g);
+    DumpVkComponentSwizzle(p, "b", obj.b);
+    DumpVkComponentSwizzle(p, "a", obj.a);
+}
+void DumpVkConformanceVersion(Printer &p, std::string name, const VkConformanceVersion &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(8);
+    p.PrintKeyValue("major", static_cast<uint32_t>(obj.major));
+    p.PrintKeyValue("minor", static_cast<uint32_t>(obj.minor));
+    p.PrintKeyValue("subminor", static_cast<uint32_t>(obj.subminor));
+    p.PrintKeyValue("patch", static_cast<uint32_t>(obj.patch));
+}
+void DumpVkCooperativeMatrixPropertiesKHR(Printer &p, std::string name, const VkCooperativeMatrixPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(22);
+    p.PrintKeyValue("MSize", obj.MSize);
+    p.PrintKeyValue("NSize", obj.NSize);
+    p.PrintKeyValue("KSize", obj.KSize);
+    DumpVkComponentTypeKHR(p, "AType", obj.AType);
+    DumpVkComponentTypeKHR(p, "BType", obj.BType);
+    DumpVkComponentTypeKHR(p, "CType", obj.CType);
+    DumpVkComponentTypeKHR(p, "ResultType", obj.ResultType);
+    p.PrintKeyBool("saturatingAccumulation", static_cast<bool>(obj.saturatingAccumulation));
+    DumpVkScopeKHR(p, "scope", obj.scope);
+}
+void DumpVkDisplayModeParametersKHR(Printer &p, std::string name, const VkDisplayModeParametersKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(11);
+    DumpVkExtent2D(p, "visibleRegion", obj.visibleRegion);
+    p.PrintKeyValue("refreshRate", obj.refreshRate);
+}
+void DumpVkDisplayModePropertiesKHR(Printer &p, std::string name, const VkDisplayModePropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkDisplayModeParametersKHR(p, "parameters", obj.parameters);
+}
+void DumpVkDisplayPlaneCapabilitiesKHR(Printer &p, std::string name, const VkDisplayPlaneCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkDisplayPlaneAlphaFlagsKHR(p, "supportedAlpha", obj.supportedAlpha);
+    DumpVkOffset2D(p, "minSrcPosition", obj.minSrcPosition);
+    DumpVkOffset2D(p, "maxSrcPosition", obj.maxSrcPosition);
+    DumpVkExtent2D(p, "minSrcExtent", obj.minSrcExtent);
+    DumpVkExtent2D(p, "maxSrcExtent", obj.maxSrcExtent);
+    DumpVkOffset2D(p, "minDstPosition", obj.minDstPosition);
+    DumpVkOffset2D(p, "maxDstPosition", obj.maxDstPosition);
+    DumpVkExtent2D(p, "minDstExtent", obj.minDstExtent);
+    DumpVkExtent2D(p, "maxDstExtent", obj.maxDstExtent);
+}
+void DumpVkDisplayPlanePropertiesKHR(Printer &p, std::string name, const VkDisplayPlanePropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyValue("currentStackIndex", obj.currentStackIndex);
+}
+void DumpVkDisplayPropertiesKHR(Printer &p, std::string name, const VkDisplayPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(20);
+    if (obj.displayName == nullptr) {
+        p.PrintKeyString("displayName", "NULL");
+    } else {
+        p.PrintKeyString("displayName", obj.displayName);
+    }
+    DumpVkExtent2D(p, "physicalDimensions", obj.physicalDimensions);
+    DumpVkExtent2D(p, "physicalResolution", obj.physicalResolution);
+    DumpVkSurfaceTransformFlagsKHR(p, "supportedTransforms", obj.supportedTransforms);
+    p.PrintKeyBool("planeReorderPossible", static_cast<bool>(obj.planeReorderPossible));
+    p.PrintKeyBool("persistentContent", static_cast<bool>(obj.persistentContent));
+}
+void DumpVkDrmFormatModifierProperties2EXT(Printer &p, std::string name, const VkDrmFormatModifierProperties2EXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(27);
+    p.PrintKeyValue("drmFormatModifier", obj.drmFormatModifier);
+    p.PrintKeyValue("drmFormatModifierPlaneCount", obj.drmFormatModifierPlaneCount);
+    p.SetOpenDetails();
+    DumpVkFormatFeatureFlags2(p, "drmFormatModifierTilingFeatures", obj.drmFormatModifierTilingFeatures);
+}
+void DumpVkExtensionProperties(Printer &p, std::string name, const VkExtensionProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(13);
+    p.PrintKeyString("extensionName", obj.extensionName);
+    p.PrintKeyValue("specVersion", obj.specVersion);
+}
+void DumpVkExtent2D(Printer &p, std::string name, const VkExtent2D &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(6);
+    p.PrintKeyValue("width", obj.width);
+    p.PrintKeyValue("height", obj.height);
+}
+void DumpVkExtent3D(Printer &p, std::string name, const VkExtent3D &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(6);
+    p.PrintKeyValue("width", obj.width);
+    p.PrintKeyValue("height", obj.height);
+    p.PrintKeyValue("depth", obj.depth);
+}
+void DumpVkFormatProperties(Printer &p, std::string name, const VkFormatProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetOpenDetails();
+    DumpVkFormatFeatureFlags(p, "linearTilingFeatures", obj.linearTilingFeatures);
+    p.SetOpenDetails();
+    DumpVkFormatFeatureFlags(p, "optimalTilingFeatures", obj.optimalTilingFeatures);
+    p.SetOpenDetails();
+    DumpVkFormatFeatureFlags(p, "bufferFeatures", obj.bufferFeatures);
+}
+void DumpVkFormatProperties3(Printer &p, std::string name, const VkFormatProperties3 &obj) {
+    ObjectWrapper object{p, name};
+    p.SetOpenDetails();
+    DumpVkFormatFeatureFlags2(p, "linearTilingFeatures", obj.linearTilingFeatures);
+    p.SetOpenDetails();
+    DumpVkFormatFeatureFlags2(p, "optimalTilingFeatures", obj.optimalTilingFeatures);
+    p.SetOpenDetails();
+    DumpVkFormatFeatureFlags2(p, "bufferFeatures", obj.bufferFeatures);
+}
+void DumpVkLayerProperties(Printer &p, std::string name, const VkLayerProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(21);
+    p.PrintKeyString("layerName", obj.layerName);
+    p.PrintKeyValue("specVersion", obj.specVersion);
+    p.PrintKeyValue("implementationVersion", obj.implementationVersion);
+    p.PrintKeyString("description", obj.description);
+}
+void DumpVkMultisamplePropertiesEXT(Printer &p, std::string name, const VkMultisamplePropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkExtent2D(p, "maxSampleLocationGridSize", obj.maxSampleLocationGridSize);
+}
+void DumpVkOffset2D(Printer &p, std::string name, const VkOffset2D &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(1);
+    p.PrintKeyValue("x", obj.x);
+    p.PrintKeyValue("y", obj.y);
+}
+void DumpVkPhysicalDevice16BitStorageFeatures(Printer &p, std::string name, const VkPhysicalDevice16BitStorageFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(34);
+    p.PrintKeyBool("storageBuffer16BitAccess", static_cast<bool>(obj.storageBuffer16BitAccess));
+    p.PrintKeyBool("uniformAndStorageBuffer16BitAccess", static_cast<bool>(obj.uniformAndStorageBuffer16BitAccess));
+    p.PrintKeyBool("storagePushConstant16", static_cast<bool>(obj.storagePushConstant16));
+    p.PrintKeyBool("storageInputOutput16", static_cast<bool>(obj.storageInputOutput16));
+}
+void DumpVkPhysicalDevice4444FormatsFeaturesEXT(Printer &p, std::string name, const VkPhysicalDevice4444FormatsFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(14);
+    p.PrintKeyBool("formatA4R4G4B4", static_cast<bool>(obj.formatA4R4G4B4));
+    p.PrintKeyBool("formatA4B4G4R4", static_cast<bool>(obj.formatA4B4G4R4));
+}
+void DumpVkPhysicalDevice8BitStorageFeatures(Printer &p, std::string name, const VkPhysicalDevice8BitStorageFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(33);
+    p.PrintKeyBool("storageBuffer8BitAccess", static_cast<bool>(obj.storageBuffer8BitAccess));
+    p.PrintKeyBool("uniformAndStorageBuffer8BitAccess", static_cast<bool>(obj.uniformAndStorageBuffer8BitAccess));
+    p.PrintKeyBool("storagePushConstant8", static_cast<bool>(obj.storagePushConstant8));
+}
+void DumpVkPhysicalDeviceASTCDecodeFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceASTCDecodeFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(24);
+    p.PrintKeyBool("decodeModeSharedExponent", static_cast<bool>(obj.decodeModeSharedExponent));
+}
+void DumpVkPhysicalDeviceAccelerationStructureFeaturesKHR(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceAccelerationStructureFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(53);
+    p.PrintKeyBool("accelerationStructure", static_cast<bool>(obj.accelerationStructure));
+    p.PrintKeyBool("accelerationStructureCaptureReplay", static_cast<bool>(obj.accelerationStructureCaptureReplay));
+    p.PrintKeyBool("accelerationStructureIndirectBuild", static_cast<bool>(obj.accelerationStructureIndirectBuild));
+    p.PrintKeyBool("accelerationStructureHostCommands", static_cast<bool>(obj.accelerationStructureHostCommands));
+    p.PrintKeyBool("descriptorBindingAccelerationStructureUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingAccelerationStructureUpdateAfterBind));
+}
+void DumpVkPhysicalDeviceAccelerationStructurePropertiesKHR(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceAccelerationStructurePropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(58);
+    p.PrintKeyValue("maxGeometryCount", obj.maxGeometryCount);
+    p.PrintKeyValue("maxInstanceCount", obj.maxInstanceCount);
+    p.PrintKeyValue("maxPrimitiveCount", obj.maxPrimitiveCount);
+    p.PrintKeyValue("maxPerStageDescriptorAccelerationStructures", obj.maxPerStageDescriptorAccelerationStructures);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindAccelerationStructures",
+                    obj.maxPerStageDescriptorUpdateAfterBindAccelerationStructures);
+    p.PrintKeyValue("maxDescriptorSetAccelerationStructures", obj.maxDescriptorSetAccelerationStructures);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindAccelerationStructures",
+                    obj.maxDescriptorSetUpdateAfterBindAccelerationStructures);
+    p.PrintKeyValue("minAccelerationStructureScratchOffsetAlignment", obj.minAccelerationStructureScratchOffsetAlignment);
+}
+void DumpVkPhysicalDeviceAddressBindingReportFeaturesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceAddressBindingReportFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(20);
+    p.PrintKeyBool("reportAddressBinding", static_cast<bool>(obj.reportAddressBinding));
+}
+void DumpVkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(34);
+    p.PrintKeyBool("attachmentFeedbackLoopDynamicState", static_cast<bool>(obj.attachmentFeedbackLoopDynamicState));
+}
+void DumpVkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(28);
+    p.PrintKeyBool("attachmentFeedbackLoopLayout", static_cast<bool>(obj.attachmentFeedbackLoopLayout));
+}
+void DumpVkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(31);
+    p.PrintKeyBool("advancedBlendCoherentOperations", static_cast<bool>(obj.advancedBlendCoherentOperations));
+}
+void DumpVkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(37);
+    p.PrintKeyValue("advancedBlendMaxColorAttachments", obj.advancedBlendMaxColorAttachments);
+    p.PrintKeyBool("advancedBlendIndependentBlend", static_cast<bool>(obj.advancedBlendIndependentBlend));
+    p.PrintKeyBool("advancedBlendNonPremultipliedSrcColor", static_cast<bool>(obj.advancedBlendNonPremultipliedSrcColor));
+    p.PrintKeyBool("advancedBlendNonPremultipliedDstColor", static_cast<bool>(obj.advancedBlendNonPremultipliedDstColor));
+    p.PrintKeyBool("advancedBlendCorrelatedOverlap", static_cast<bool>(obj.advancedBlendCorrelatedOverlap));
+    p.PrintKeyBool("advancedBlendAllOperations", static_cast<bool>(obj.advancedBlendAllOperations));
+}
+void DumpVkPhysicalDeviceBorderColorSwizzleFeaturesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(27);
+    p.PrintKeyBool("borderColorSwizzle", static_cast<bool>(obj.borderColorSwizzle));
+    p.PrintKeyBool("borderColorSwizzleFromImage", static_cast<bool>(obj.borderColorSwizzleFromImage));
+}
+void DumpVkPhysicalDeviceBufferDeviceAddressFeatures(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceBufferDeviceAddressFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(32);
+    p.PrintKeyBool("bufferDeviceAddress", static_cast<bool>(obj.bufferDeviceAddress));
+    p.PrintKeyBool("bufferDeviceAddressCaptureReplay", static_cast<bool>(obj.bufferDeviceAddressCaptureReplay));
+    p.PrintKeyBool("bufferDeviceAddressMultiDevice", static_cast<bool>(obj.bufferDeviceAddressMultiDevice));
+}
+void DumpVkPhysicalDeviceBufferDeviceAddressFeaturesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(32);
+    p.PrintKeyBool("bufferDeviceAddress", static_cast<bool>(obj.bufferDeviceAddress));
+    p.PrintKeyBool("bufferDeviceAddressCaptureReplay", static_cast<bool>(obj.bufferDeviceAddressCaptureReplay));
+    p.PrintKeyBool("bufferDeviceAddressMultiDevice", static_cast<bool>(obj.bufferDeviceAddressMultiDevice));
+}
+void DumpVkPhysicalDeviceColorWriteEnableFeaturesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceColorWriteEnableFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(16);
+    p.PrintKeyBool("colorWriteEnable", static_cast<bool>(obj.colorWriteEnable));
+}
+void DumpVkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(28);
+    p.PrintKeyBool("computeDerivativeGroupQuads", static_cast<bool>(obj.computeDerivativeGroupQuads));
+    p.PrintKeyBool("computeDerivativeGroupLinear", static_cast<bool>(obj.computeDerivativeGroupLinear));
+}
+void DumpVkPhysicalDeviceComputeShaderDerivativesPropertiesKHR(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(28);
+    p.PrintKeyBool("meshAndTaskShaderDerivatives", static_cast<bool>(obj.meshAndTaskShaderDerivatives));
+}
+void DumpVkPhysicalDeviceConditionalRenderingFeaturesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceConditionalRenderingFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(29);
+    p.PrintKeyBool("conditionalRendering", static_cast<bool>(obj.conditionalRendering));
+    p.PrintKeyBool("inheritedConditionalRendering", static_cast<bool>(obj.inheritedConditionalRendering));
+}
+void DumpVkPhysicalDeviceConservativeRasterizationPropertiesEXT(Printer &p, std::string name,
+                                                                const VkPhysicalDeviceConservativeRasterizationPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(43);
+    p.PrintKeyValue("primitiveOverestimationSize", obj.primitiveOverestimationSize);
+    p.PrintKeyValue("maxExtraPrimitiveOverestimationSize", obj.maxExtraPrimitiveOverestimationSize);
+    p.PrintKeyValue("extraPrimitiveOverestimationSizeGranularity", obj.extraPrimitiveOverestimationSizeGranularity);
+    p.PrintKeyBool("primitiveUnderestimation", static_cast<bool>(obj.primitiveUnderestimation));
+    p.PrintKeyBool("conservativePointAndLineRasterization", static_cast<bool>(obj.conservativePointAndLineRasterization));
+    p.PrintKeyBool("degenerateTrianglesRasterized", static_cast<bool>(obj.degenerateTrianglesRasterized));
+    p.PrintKeyBool("degenerateLinesRasterized", static_cast<bool>(obj.degenerateLinesRasterized));
+    p.PrintKeyBool("fullyCoveredFragmentShaderInputVariable", static_cast<bool>(obj.fullyCoveredFragmentShaderInputVariable));
+    p.PrintKeyBool("conservativeRasterizationPostDepthCoverage", static_cast<bool>(obj.conservativeRasterizationPostDepthCoverage));
+}
+void DumpVkPhysicalDeviceCooperativeMatrixFeaturesKHR(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceCooperativeMatrixFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(35);
+    p.PrintKeyBool("cooperativeMatrix", static_cast<bool>(obj.cooperativeMatrix));
+    p.PrintKeyBool("cooperativeMatrixRobustBufferAccess", static_cast<bool>(obj.cooperativeMatrixRobustBufferAccess));
+}
+void DumpVkPhysicalDeviceCooperativeMatrixPropertiesKHR(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceCooperativeMatrixPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkShaderStageFlags(p, "cooperativeMatrixSupportedStages", obj.cooperativeMatrixSupportedStages);
+}
+void DumpVkPhysicalDeviceCopyMemoryIndirectFeaturesKHR(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(25);
+    p.PrintKeyBool("indirectMemoryCopy", static_cast<bool>(obj.indirectMemoryCopy));
+    p.PrintKeyBool("indirectMemoryToImageCopy", static_cast<bool>(obj.indirectMemoryToImageCopy));
+}
+void DumpVkPhysicalDeviceCopyMemoryIndirectPropertiesKHR(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkQueueFlags(p, "supportedQueues", obj.supportedQueues);
+}
+void DumpVkPhysicalDeviceCustomBorderColorFeaturesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceCustomBorderColorFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(30);
+    p.PrintKeyBool("customBorderColors", static_cast<bool>(obj.customBorderColors));
+    p.PrintKeyBool("customBorderColorWithoutFormat", static_cast<bool>(obj.customBorderColorWithoutFormat));
+}
+void DumpVkPhysicalDeviceCustomBorderColorPropertiesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceCustomBorderColorPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(28);
+    p.PrintKeyValue("maxCustomBorderColorSamplers", obj.maxCustomBorderColorSamplers);
+}
+void DumpVkPhysicalDeviceCustomResolveFeaturesEXT(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceCustomResolveFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(13);
+    p.PrintKeyBool("customResolve", static_cast<bool>(obj.customResolve));
+}
+void DumpVkPhysicalDeviceDepthBiasControlFeaturesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceDepthBiasControlFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(47);
+    p.PrintKeyBool("depthBiasControl", static_cast<bool>(obj.depthBiasControl));
+    p.PrintKeyBool("leastRepresentableValueForceUnormRepresentation",
+                   static_cast<bool>(obj.leastRepresentableValueForceUnormRepresentation));
+    p.PrintKeyBool("floatRepresentation", static_cast<bool>(obj.floatRepresentation));
+    p.PrintKeyBool("depthBiasExact", static_cast<bool>(obj.depthBiasExact));
+}
+void DumpVkPhysicalDeviceDepthClampControlFeaturesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceDepthClampControlFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyBool("depthClampControl", static_cast<bool>(obj.depthClampControl));
+}
+void DumpVkPhysicalDeviceDepthClampZeroOneFeaturesKHR(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyBool("depthClampZeroOne", static_cast<bool>(obj.depthClampZeroOne));
+}
+void DumpVkPhysicalDeviceDepthClipControlFeaturesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceDepthClipControlFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(16);
+    p.PrintKeyBool("depthClipControl", static_cast<bool>(obj.depthClipControl));
+}
+void DumpVkPhysicalDeviceDepthClipEnableFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceDepthClipEnableFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(15);
+    p.PrintKeyBool("depthClipEnable", static_cast<bool>(obj.depthClipEnable));
+}
+void DumpVkPhysicalDeviceDepthStencilResolveProperties(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceDepthStencilResolveProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(22);
+    DumpVkResolveModeFlags(p, "supportedDepthResolveModes", obj.supportedDepthResolveModes);
+    DumpVkResolveModeFlags(p, "supportedStencilResolveModes", obj.supportedStencilResolveModes);
+    p.PrintKeyBool("independentResolveNone", static_cast<bool>(obj.independentResolveNone));
+    p.PrintKeyBool("independentResolve", static_cast<bool>(obj.independentResolve));
+}
+void DumpVkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(44);
+    p.PrintKeyValue("combinedImageSamplerDensityMapDescriptorSize", obj.combinedImageSamplerDensityMapDescriptorSize);
+}
+void DumpVkPhysicalDeviceDescriptorBufferFeaturesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceDescriptorBufferFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(34);
+    p.PrintKeyBool("descriptorBuffer", static_cast<bool>(obj.descriptorBuffer));
+    p.PrintKeyBool("descriptorBufferCaptureReplay", static_cast<bool>(obj.descriptorBufferCaptureReplay));
+    p.PrintKeyBool("descriptorBufferImageLayoutIgnored", static_cast<bool>(obj.descriptorBufferImageLayoutIgnored));
+    p.PrintKeyBool("descriptorBufferPushDescriptors", static_cast<bool>(obj.descriptorBufferPushDescriptors));
+}
+void DumpVkPhysicalDeviceDescriptorBufferPropertiesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceDescriptorBufferPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(52);
+    p.PrintKeyBool("combinedImageSamplerDescriptorSingleArray", static_cast<bool>(obj.combinedImageSamplerDescriptorSingleArray));
+    p.PrintKeyBool("bufferlessPushDescriptors", static_cast<bool>(obj.bufferlessPushDescriptors));
+    p.PrintKeyBool("allowSamplerImageViewPostSubmitCreation", static_cast<bool>(obj.allowSamplerImageViewPostSubmitCreation));
+    p.PrintKeyValue("descriptorBufferOffsetAlignment", to_hex_str(p, obj.descriptorBufferOffsetAlignment));
+    p.PrintKeyValue("maxDescriptorBufferBindings", obj.maxDescriptorBufferBindings);
+    p.PrintKeyValue("maxResourceDescriptorBufferBindings", obj.maxResourceDescriptorBufferBindings);
+    p.PrintKeyValue("maxSamplerDescriptorBufferBindings", obj.maxSamplerDescriptorBufferBindings);
+    p.PrintKeyValue("maxEmbeddedImmutableSamplerBindings", obj.maxEmbeddedImmutableSamplerBindings);
+    p.PrintKeyValue("maxEmbeddedImmutableSamplers", obj.maxEmbeddedImmutableSamplers);
+    p.PrintKeyValue("bufferCaptureReplayDescriptorDataSize", obj.bufferCaptureReplayDescriptorDataSize);
+    p.PrintKeyValue("imageCaptureReplayDescriptorDataSize", obj.imageCaptureReplayDescriptorDataSize);
+    p.PrintKeyValue("imageViewCaptureReplayDescriptorDataSize", obj.imageViewCaptureReplayDescriptorDataSize);
+    p.PrintKeyValue("samplerCaptureReplayDescriptorDataSize", obj.samplerCaptureReplayDescriptorDataSize);
+    p.PrintKeyValue("accelerationStructureCaptureReplayDescriptorDataSize",
+                    obj.accelerationStructureCaptureReplayDescriptorDataSize);
+    p.PrintKeyValue("samplerDescriptorSize", obj.samplerDescriptorSize);
+    p.PrintKeyValue("combinedImageSamplerDescriptorSize", obj.combinedImageSamplerDescriptorSize);
+    p.PrintKeyValue("sampledImageDescriptorSize", obj.sampledImageDescriptorSize);
+    p.PrintKeyValue("storageImageDescriptorSize", obj.storageImageDescriptorSize);
+    p.PrintKeyValue("uniformTexelBufferDescriptorSize", obj.uniformTexelBufferDescriptorSize);
+    p.PrintKeyValue("robustUniformTexelBufferDescriptorSize", obj.robustUniformTexelBufferDescriptorSize);
+    p.PrintKeyValue("storageTexelBufferDescriptorSize", obj.storageTexelBufferDescriptorSize);
+    p.PrintKeyValue("robustStorageTexelBufferDescriptorSize", obj.robustStorageTexelBufferDescriptorSize);
+    p.PrintKeyValue("uniformBufferDescriptorSize", obj.uniformBufferDescriptorSize);
+    p.PrintKeyValue("robustUniformBufferDescriptorSize", obj.robustUniformBufferDescriptorSize);
+    p.PrintKeyValue("storageBufferDescriptorSize", obj.storageBufferDescriptorSize);
+    p.PrintKeyValue("robustStorageBufferDescriptorSize", obj.robustStorageBufferDescriptorSize);
+    p.PrintKeyValue("inputAttachmentDescriptorSize", obj.inputAttachmentDescriptorSize);
+    p.PrintKeyValue("accelerationStructureDescriptorSize", obj.accelerationStructureDescriptorSize);
+    p.PrintKeyValue("maxSamplerDescriptorBufferRange", to_hex_str(p, obj.maxSamplerDescriptorBufferRange));
+    p.PrintKeyValue("maxResourceDescriptorBufferRange", to_hex_str(p, obj.maxResourceDescriptorBufferRange));
+    p.PrintKeyValue("samplerDescriptorBufferAddressSpaceSize", to_hex_str(p, obj.samplerDescriptorBufferAddressSpaceSize));
+    p.PrintKeyValue("resourceDescriptorBufferAddressSpaceSize", to_hex_str(p, obj.resourceDescriptorBufferAddressSpaceSize));
+    p.PrintKeyValue("descriptorBufferAddressSpaceSize", to_hex_str(p, obj.descriptorBufferAddressSpaceSize));
+}
+void DumpVkPhysicalDeviceDescriptorHeapFeaturesEXT(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceDescriptorHeapFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(27);
+    p.PrintKeyBool("descriptorHeap", static_cast<bool>(obj.descriptorHeap));
+    p.PrintKeyBool("descriptorHeapCaptureReplay", static_cast<bool>(obj.descriptorHeapCaptureReplay));
+}
+void DumpVkPhysicalDeviceDescriptorHeapPropertiesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceDescriptorHeapPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(39);
+    p.PrintKeyValue("samplerHeapAlignment", to_hex_str(p, obj.samplerHeapAlignment));
+    p.PrintKeyValue("resourceHeapAlignment", to_hex_str(p, obj.resourceHeapAlignment));
+    p.PrintKeyValue("maxSamplerHeapSize", to_hex_str(p, obj.maxSamplerHeapSize));
+    p.PrintKeyValue("maxResourceHeapSize", to_hex_str(p, obj.maxResourceHeapSize));
+    p.PrintKeyValue("minSamplerHeapReservedRange", to_hex_str(p, obj.minSamplerHeapReservedRange));
+    p.PrintKeyValue("minSamplerHeapReservedRangeWithEmbedded", to_hex_str(p, obj.minSamplerHeapReservedRangeWithEmbedded));
+    p.PrintKeyValue("minResourceHeapReservedRange", to_hex_str(p, obj.minResourceHeapReservedRange));
+    p.PrintKeyValue("samplerDescriptorSize", to_hex_str(p, obj.samplerDescriptorSize));
+    p.PrintKeyValue("imageDescriptorSize", to_hex_str(p, obj.imageDescriptorSize));
+    p.PrintKeyValue("bufferDescriptorSize", to_hex_str(p, obj.bufferDescriptorSize));
+    p.PrintKeyValue("samplerDescriptorAlignment", to_hex_str(p, obj.samplerDescriptorAlignment));
+    p.PrintKeyValue("imageDescriptorAlignment", to_hex_str(p, obj.imageDescriptorAlignment));
+    p.PrintKeyValue("bufferDescriptorAlignment", to_hex_str(p, obj.bufferDescriptorAlignment));
+    p.PrintKeyValue("maxPushDataSize", to_hex_str(p, obj.maxPushDataSize));
+    p.PrintKeyValue("imageCaptureReplayOpaqueDataSize", obj.imageCaptureReplayOpaqueDataSize);
+    p.PrintKeyValue("maxDescriptorHeapEmbeddedSamplers", obj.maxDescriptorHeapEmbeddedSamplers);
+    p.PrintKeyValue("samplerYcbcrConversionCount", obj.samplerYcbcrConversionCount);
+    p.PrintKeyBool("sparseDescriptorHeaps", static_cast<bool>(obj.sparseDescriptorHeaps));
+    p.PrintKeyBool("protectedDescriptorHeaps", static_cast<bool>(obj.protectedDescriptorHeaps));
+}
+void DumpVkPhysicalDeviceDescriptorHeapTensorPropertiesARM(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceDescriptorHeapTensorPropertiesARM &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(33);
+    p.PrintKeyValue("tensorDescriptorSize", to_hex_str(p, obj.tensorDescriptorSize));
+    p.PrintKeyValue("tensorDescriptorAlignment", to_hex_str(p, obj.tensorDescriptorAlignment));
+    p.PrintKeyValue("tensorCaptureReplayOpaqueDataSize", obj.tensorCaptureReplayOpaqueDataSize);
+}
+void DumpVkPhysicalDeviceDescriptorIndexingFeatures(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceDescriptorIndexingFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(50);
+    p.PrintKeyBool("shaderInputAttachmentArrayDynamicIndexing", static_cast<bool>(obj.shaderInputAttachmentArrayDynamicIndexing));
+    p.PrintKeyBool("shaderUniformTexelBufferArrayDynamicIndexing",
+                   static_cast<bool>(obj.shaderUniformTexelBufferArrayDynamicIndexing));
+    p.PrintKeyBool("shaderStorageTexelBufferArrayDynamicIndexing",
+                   static_cast<bool>(obj.shaderStorageTexelBufferArrayDynamicIndexing));
+    p.PrintKeyBool("shaderUniformBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderUniformBufferArrayNonUniformIndexing));
+    p.PrintKeyBool("shaderSampledImageArrayNonUniformIndexing", static_cast<bool>(obj.shaderSampledImageArrayNonUniformIndexing));
+    p.PrintKeyBool("shaderStorageBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageBufferArrayNonUniformIndexing));
+    p.PrintKeyBool("shaderStorageImageArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageImageArrayNonUniformIndexing));
+    p.PrintKeyBool("shaderInputAttachmentArrayNonUniformIndexing",
+                   static_cast<bool>(obj.shaderInputAttachmentArrayNonUniformIndexing));
+    p.PrintKeyBool("shaderUniformTexelBufferArrayNonUniformIndexing",
+                   static_cast<bool>(obj.shaderUniformTexelBufferArrayNonUniformIndexing));
+    p.PrintKeyBool("shaderStorageTexelBufferArrayNonUniformIndexing",
+                   static_cast<bool>(obj.shaderStorageTexelBufferArrayNonUniformIndexing));
+    p.PrintKeyBool("descriptorBindingUniformBufferUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingUniformBufferUpdateAfterBind));
+    p.PrintKeyBool("descriptorBindingSampledImageUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingSampledImageUpdateAfterBind));
+    p.PrintKeyBool("descriptorBindingStorageImageUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingStorageImageUpdateAfterBind));
+    p.PrintKeyBool("descriptorBindingStorageBufferUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingStorageBufferUpdateAfterBind));
+    p.PrintKeyBool("descriptorBindingUniformTexelBufferUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingUniformTexelBufferUpdateAfterBind));
+    p.PrintKeyBool("descriptorBindingStorageTexelBufferUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingStorageTexelBufferUpdateAfterBind));
+    p.PrintKeyBool("descriptorBindingUpdateUnusedWhilePending", static_cast<bool>(obj.descriptorBindingUpdateUnusedWhilePending));
+    p.PrintKeyBool("descriptorBindingPartiallyBound", static_cast<bool>(obj.descriptorBindingPartiallyBound));
+    p.PrintKeyBool("descriptorBindingVariableDescriptorCount", static_cast<bool>(obj.descriptorBindingVariableDescriptorCount));
+    p.PrintKeyBool("runtimeDescriptorArray", static_cast<bool>(obj.runtimeDescriptorArray));
+}
+void DumpVkPhysicalDeviceDescriptorIndexingProperties(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceDescriptorIndexingProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(52);
+    p.PrintKeyValue("maxUpdateAfterBindDescriptorsInAllPools", obj.maxUpdateAfterBindDescriptorsInAllPools);
+    p.PrintKeyBool("shaderUniformBufferArrayNonUniformIndexingNative",
+                   static_cast<bool>(obj.shaderUniformBufferArrayNonUniformIndexingNative));
+    p.PrintKeyBool("shaderSampledImageArrayNonUniformIndexingNative",
+                   static_cast<bool>(obj.shaderSampledImageArrayNonUniformIndexingNative));
+    p.PrintKeyBool("shaderStorageBufferArrayNonUniformIndexingNative",
+                   static_cast<bool>(obj.shaderStorageBufferArrayNonUniformIndexingNative));
+    p.PrintKeyBool("shaderStorageImageArrayNonUniformIndexingNative",
+                   static_cast<bool>(obj.shaderStorageImageArrayNonUniformIndexingNative));
+    p.PrintKeyBool("shaderInputAttachmentArrayNonUniformIndexingNative",
+                   static_cast<bool>(obj.shaderInputAttachmentArrayNonUniformIndexingNative));
+    p.PrintKeyBool("robustBufferAccessUpdateAfterBind", static_cast<bool>(obj.robustBufferAccessUpdateAfterBind));
+    p.PrintKeyBool("quadDivergentImplicitLod", static_cast<bool>(obj.quadDivergentImplicitLod));
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindSamplers", obj.maxPerStageDescriptorUpdateAfterBindSamplers);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindUniformBuffers", obj.maxPerStageDescriptorUpdateAfterBindUniformBuffers);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindStorageBuffers", obj.maxPerStageDescriptorUpdateAfterBindStorageBuffers);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindSampledImages", obj.maxPerStageDescriptorUpdateAfterBindSampledImages);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindStorageImages", obj.maxPerStageDescriptorUpdateAfterBindStorageImages);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindInputAttachments",
+                    obj.maxPerStageDescriptorUpdateAfterBindInputAttachments);
+    p.PrintKeyValue("maxPerStageUpdateAfterBindResources", obj.maxPerStageUpdateAfterBindResources);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindSamplers", obj.maxDescriptorSetUpdateAfterBindSamplers);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindUniformBuffers", obj.maxDescriptorSetUpdateAfterBindUniformBuffers);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindUniformBuffersDynamic",
+                    obj.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageBuffers", obj.maxDescriptorSetUpdateAfterBindStorageBuffers);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageBuffersDynamic",
+                    obj.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindSampledImages", obj.maxDescriptorSetUpdateAfterBindSampledImages);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageImages", obj.maxDescriptorSetUpdateAfterBindStorageImages);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindInputAttachments", obj.maxDescriptorSetUpdateAfterBindInputAttachments);
+}
+void DumpVkPhysicalDeviceDeviceAddressCommandsFeaturesKHR(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(21);
+    p.PrintKeyBool("deviceAddressCommands", static_cast<bool>(obj.deviceAddressCommands));
+}
+void DumpVkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(30);
+    p.PrintKeyBool("deviceGeneratedCommands", static_cast<bool>(obj.deviceGeneratedCommands));
+    p.PrintKeyBool("dynamicGeneratedPipelineLayout", static_cast<bool>(obj.dynamicGeneratedPipelineLayout));
+}
+void DumpVkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(Printer &p, std::string name,
+                                                              const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(45);
+    p.PrintKeyValue("maxIndirectPipelineCount", obj.maxIndirectPipelineCount);
+    p.PrintKeyValue("maxIndirectShaderObjectCount", obj.maxIndirectShaderObjectCount);
+    p.PrintKeyValue("maxIndirectSequenceCount", obj.maxIndirectSequenceCount);
+    p.PrintKeyValue("maxIndirectCommandsTokenCount", obj.maxIndirectCommandsTokenCount);
+    p.PrintKeyValue("maxIndirectCommandsTokenOffset", obj.maxIndirectCommandsTokenOffset);
+    p.PrintKeyValue("maxIndirectCommandsIndirectStride", obj.maxIndirectCommandsIndirectStride);
+    DumpVkIndirectCommandsInputModeFlagsEXT(p, "supportedIndirectCommandsInputModes", obj.supportedIndirectCommandsInputModes);
+    DumpVkShaderStageFlags(p, "supportedIndirectCommandsShaderStages", obj.supportedIndirectCommandsShaderStages);
+    DumpVkShaderStageFlags(p, "supportedIndirectCommandsShaderStagesPipelineBinding",
+                           obj.supportedIndirectCommandsShaderStagesPipelineBinding);
+    DumpVkShaderStageFlags(p, "supportedIndirectCommandsShaderStagesShaderBinding",
+                           obj.supportedIndirectCommandsShaderStagesShaderBinding);
+    p.PrintKeyBool("deviceGeneratedCommandsTransformFeedback", static_cast<bool>(obj.deviceGeneratedCommandsTransformFeedback));
+    p.PrintKeyBool("deviceGeneratedCommandsMultiDrawIndirectCount",
+                   static_cast<bool>(obj.deviceGeneratedCommandsMultiDrawIndirectCount));
+}
+void DumpVkPhysicalDeviceDeviceMemoryReportFeaturesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(18);
+    p.PrintKeyBool("deviceMemoryReport", static_cast<bool>(obj.deviceMemoryReport));
+}
+void DumpVkPhysicalDeviceDiscardRectanglePropertiesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceDiscardRectanglePropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(20);
+    p.PrintKeyValue("maxDiscardRectangles", obj.maxDiscardRectangles);
+}
+void DumpVkPhysicalDeviceDriverProperties(Printer &p, std::string name, const VkPhysicalDeviceDriverProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(10);
+    DumpVkDriverId(p, "driverID", obj.driverID);
+    p.PrintKeyString("driverName", obj.driverName);
+    p.PrintKeyString("driverInfo", obj.driverInfo);
+    DumpVkConformanceVersion(p, "conformanceVersion", obj.conformanceVersion);
+}
+void DumpVkPhysicalDeviceDrmPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceDrmPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(12);
+    p.PrintKeyBool("hasPrimary", static_cast<bool>(obj.hasPrimary));
+    p.PrintKeyBool("hasRender", static_cast<bool>(obj.hasRender));
+    p.PrintKeyValue("primaryMajor", obj.primaryMajor);
+    p.PrintKeyValue("primaryMinor", obj.primaryMinor);
+    p.PrintKeyValue("renderMajor", obj.renderMajor);
+    p.PrintKeyValue("renderMinor", obj.renderMinor);
+}
+void DumpVkPhysicalDeviceDynamicRenderingFeatures(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceDynamicRenderingFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(16);
+    p.PrintKeyBool("dynamicRendering", static_cast<bool>(obj.dynamicRendering));
+}
+void DumpVkPhysicalDeviceDynamicRenderingLocalReadFeatures(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceDynamicRenderingLocalReadFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(25);
+    p.PrintKeyBool("dynamicRenderingLocalRead", static_cast<bool>(obj.dynamicRenderingLocalRead));
+}
+void DumpVkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(33);
+    p.PrintKeyBool("dynamicRenderingUnusedAttachments", static_cast<bool>(obj.dynamicRenderingUnusedAttachments));
+}
+void DumpVkPhysicalDeviceExtendedDynamicState2FeaturesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(39);
+    p.PrintKeyBool("extendedDynamicState2", static_cast<bool>(obj.extendedDynamicState2));
+    p.PrintKeyBool("extendedDynamicState2LogicOp", static_cast<bool>(obj.extendedDynamicState2LogicOp));
+    p.PrintKeyBool("extendedDynamicState2PatchControlPoints", static_cast<bool>(obj.extendedDynamicState2PatchControlPoints));
+}
+void DumpVkPhysicalDeviceExtendedDynamicState3FeaturesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(53);
+    p.PrintKeyBool("extendedDynamicState3TessellationDomainOrigin",
+                   static_cast<bool>(obj.extendedDynamicState3TessellationDomainOrigin));
+    p.PrintKeyBool("extendedDynamicState3DepthClampEnable", static_cast<bool>(obj.extendedDynamicState3DepthClampEnable));
+    p.PrintKeyBool("extendedDynamicState3PolygonMode", static_cast<bool>(obj.extendedDynamicState3PolygonMode));
+    p.PrintKeyBool("extendedDynamicState3RasterizationSamples", static_cast<bool>(obj.extendedDynamicState3RasterizationSamples));
+    p.PrintKeyBool("extendedDynamicState3SampleMask", static_cast<bool>(obj.extendedDynamicState3SampleMask));
+    p.PrintKeyBool("extendedDynamicState3AlphaToCoverageEnable", static_cast<bool>(obj.extendedDynamicState3AlphaToCoverageEnable));
+    p.PrintKeyBool("extendedDynamicState3AlphaToOneEnable", static_cast<bool>(obj.extendedDynamicState3AlphaToOneEnable));
+    p.PrintKeyBool("extendedDynamicState3LogicOpEnable", static_cast<bool>(obj.extendedDynamicState3LogicOpEnable));
+    p.PrintKeyBool("extendedDynamicState3ColorBlendEnable", static_cast<bool>(obj.extendedDynamicState3ColorBlendEnable));
+    p.PrintKeyBool("extendedDynamicState3ColorBlendEquation", static_cast<bool>(obj.extendedDynamicState3ColorBlendEquation));
+    p.PrintKeyBool("extendedDynamicState3ColorWriteMask", static_cast<bool>(obj.extendedDynamicState3ColorWriteMask));
+    p.PrintKeyBool("extendedDynamicState3RasterizationStream", static_cast<bool>(obj.extendedDynamicState3RasterizationStream));
+    p.PrintKeyBool("extendedDynamicState3ConservativeRasterizationMode",
+                   static_cast<bool>(obj.extendedDynamicState3ConservativeRasterizationMode));
+    p.PrintKeyBool("extendedDynamicState3ExtraPrimitiveOverestimationSize",
+                   static_cast<bool>(obj.extendedDynamicState3ExtraPrimitiveOverestimationSize));
+    p.PrintKeyBool("extendedDynamicState3DepthClipEnable", static_cast<bool>(obj.extendedDynamicState3DepthClipEnable));
+    p.PrintKeyBool("extendedDynamicState3SampleLocationsEnable", static_cast<bool>(obj.extendedDynamicState3SampleLocationsEnable));
+    p.PrintKeyBool("extendedDynamicState3ColorBlendAdvanced", static_cast<bool>(obj.extendedDynamicState3ColorBlendAdvanced));
+    p.PrintKeyBool("extendedDynamicState3ProvokingVertexMode", static_cast<bool>(obj.extendedDynamicState3ProvokingVertexMode));
+    p.PrintKeyBool("extendedDynamicState3LineRasterizationMode", static_cast<bool>(obj.extendedDynamicState3LineRasterizationMode));
+    p.PrintKeyBool("extendedDynamicState3LineStippleEnable", static_cast<bool>(obj.extendedDynamicState3LineStippleEnable));
+    p.PrintKeyBool("extendedDynamicState3DepthClipNegativeOneToOne",
+                   static_cast<bool>(obj.extendedDynamicState3DepthClipNegativeOneToOne));
+    p.PrintKeyBool("extendedDynamicState3ViewportWScalingEnable",
+                   static_cast<bool>(obj.extendedDynamicState3ViewportWScalingEnable));
+    p.PrintKeyBool("extendedDynamicState3ViewportSwizzle", static_cast<bool>(obj.extendedDynamicState3ViewportSwizzle));
+    p.PrintKeyBool("extendedDynamicState3CoverageToColorEnable", static_cast<bool>(obj.extendedDynamicState3CoverageToColorEnable));
+    p.PrintKeyBool("extendedDynamicState3CoverageToColorLocation",
+                   static_cast<bool>(obj.extendedDynamicState3CoverageToColorLocation));
+    p.PrintKeyBool("extendedDynamicState3CoverageModulationMode",
+                   static_cast<bool>(obj.extendedDynamicState3CoverageModulationMode));
+    p.PrintKeyBool("extendedDynamicState3CoverageModulationTableEnable",
+                   static_cast<bool>(obj.extendedDynamicState3CoverageModulationTableEnable));
+    p.PrintKeyBool("extendedDynamicState3CoverageModulationTable",
+                   static_cast<bool>(obj.extendedDynamicState3CoverageModulationTable));
+    p.PrintKeyBool("extendedDynamicState3CoverageReductionMode", static_cast<bool>(obj.extendedDynamicState3CoverageReductionMode));
+    p.PrintKeyBool("extendedDynamicState3RepresentativeFragmentTestEnable",
+                   static_cast<bool>(obj.extendedDynamicState3RepresentativeFragmentTestEnable));
+    p.PrintKeyBool("extendedDynamicState3ShadingRateImageEnable",
+                   static_cast<bool>(obj.extendedDynamicState3ShadingRateImageEnable));
+}
+void DumpVkPhysicalDeviceExtendedDynamicState3PropertiesEXT(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(36);
+    p.PrintKeyBool("dynamicPrimitiveTopologyUnrestricted", static_cast<bool>(obj.dynamicPrimitiveTopologyUnrestricted));
+}
+void DumpVkPhysicalDeviceExtendedDynamicStateFeaturesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(20);
+    p.PrintKeyBool("extendedDynamicState", static_cast<bool>(obj.extendedDynamicState));
+}
+void DumpVkPhysicalDeviceExternalMemoryHostPropertiesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceExternalMemoryHostPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(31);
+    p.PrintKeyValue("minImportedHostPointerAlignment", to_hex_str(p, obj.minImportedHostPointerAlignment));
+}
+void DumpVkPhysicalDeviceFaultFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceFaultFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(23);
+    p.PrintKeyBool("deviceFault", static_cast<bool>(obj.deviceFault));
+    p.PrintKeyBool("deviceFaultVendorBinary", static_cast<bool>(obj.deviceFaultVendorBinary));
+}
+void DumpVkPhysicalDeviceFaultFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceFaultFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(29);
+    p.PrintKeyBool("deviceFault", static_cast<bool>(obj.deviceFault));
+    p.PrintKeyBool("deviceFaultVendorBinary", static_cast<bool>(obj.deviceFaultVendorBinary));
+    p.PrintKeyBool("deviceFaultReportMasked", static_cast<bool>(obj.deviceFaultReportMasked));
+    p.PrintKeyBool("deviceFaultDeviceLostOnMasked", static_cast<bool>(obj.deviceFaultDeviceLostOnMasked));
+}
+void DumpVkPhysicalDeviceFaultPropertiesKHR(Printer &p, std::string name, const VkPhysicalDeviceFaultPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(19);
+    p.PrintKeyValue("maxDeviceFaultCount", obj.maxDeviceFaultCount);
+}
+void DumpVkPhysicalDeviceFeatures(Printer &p, std::string name, const VkPhysicalDeviceFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(39);
+    p.PrintKeyBool("robustBufferAccess", static_cast<bool>(obj.robustBufferAccess));
+    p.PrintKeyBool("fullDrawIndexUint32", static_cast<bool>(obj.fullDrawIndexUint32));
+    p.PrintKeyBool("imageCubeArray", static_cast<bool>(obj.imageCubeArray));
+    p.PrintKeyBool("independentBlend", static_cast<bool>(obj.independentBlend));
+    p.PrintKeyBool("geometryShader", static_cast<bool>(obj.geometryShader));
+    p.PrintKeyBool("tessellationShader", static_cast<bool>(obj.tessellationShader));
+    p.PrintKeyBool("sampleRateShading", static_cast<bool>(obj.sampleRateShading));
+    p.PrintKeyBool("dualSrcBlend", static_cast<bool>(obj.dualSrcBlend));
+    p.PrintKeyBool("logicOp", static_cast<bool>(obj.logicOp));
+    p.PrintKeyBool("multiDrawIndirect", static_cast<bool>(obj.multiDrawIndirect));
+    p.PrintKeyBool("drawIndirectFirstInstance", static_cast<bool>(obj.drawIndirectFirstInstance));
+    p.PrintKeyBool("depthClamp", static_cast<bool>(obj.depthClamp));
+    p.PrintKeyBool("depthBiasClamp", static_cast<bool>(obj.depthBiasClamp));
+    p.PrintKeyBool("fillModeNonSolid", static_cast<bool>(obj.fillModeNonSolid));
+    p.PrintKeyBool("depthBounds", static_cast<bool>(obj.depthBounds));
+    p.PrintKeyBool("wideLines", static_cast<bool>(obj.wideLines));
+    p.PrintKeyBool("largePoints", static_cast<bool>(obj.largePoints));
+    p.PrintKeyBool("alphaToOne", static_cast<bool>(obj.alphaToOne));
+    p.PrintKeyBool("multiViewport", static_cast<bool>(obj.multiViewport));
+    p.PrintKeyBool("samplerAnisotropy", static_cast<bool>(obj.samplerAnisotropy));
+    p.PrintKeyBool("textureCompressionETC2", static_cast<bool>(obj.textureCompressionETC2));
+    p.PrintKeyBool("textureCompressionASTC_LDR", static_cast<bool>(obj.textureCompressionASTC_LDR));
+    p.PrintKeyBool("textureCompressionBC", static_cast<bool>(obj.textureCompressionBC));
+    p.PrintKeyBool("occlusionQueryPrecise", static_cast<bool>(obj.occlusionQueryPrecise));
+    p.PrintKeyBool("pipelineStatisticsQuery", static_cast<bool>(obj.pipelineStatisticsQuery));
+    p.PrintKeyBool("vertexPipelineStoresAndAtomics", static_cast<bool>(obj.vertexPipelineStoresAndAtomics));
+    p.PrintKeyBool("fragmentStoresAndAtomics", static_cast<bool>(obj.fragmentStoresAndAtomics));
+    p.PrintKeyBool("shaderTessellationAndGeometryPointSize", static_cast<bool>(obj.shaderTessellationAndGeometryPointSize));
+    p.PrintKeyBool("shaderImageGatherExtended", static_cast<bool>(obj.shaderImageGatherExtended));
+    p.PrintKeyBool("shaderStorageImageExtendedFormats", static_cast<bool>(obj.shaderStorageImageExtendedFormats));
+    p.PrintKeyBool("shaderStorageImageMultisample", static_cast<bool>(obj.shaderStorageImageMultisample));
+    p.PrintKeyBool("shaderStorageImageReadWithoutFormat", static_cast<bool>(obj.shaderStorageImageReadWithoutFormat));
+    p.PrintKeyBool("shaderStorageImageWriteWithoutFormat", static_cast<bool>(obj.shaderStorageImageWriteWithoutFormat));
+    p.PrintKeyBool("shaderUniformBufferArrayDynamicIndexing", static_cast<bool>(obj.shaderUniformBufferArrayDynamicIndexing));
+    p.PrintKeyBool("shaderSampledImageArrayDynamicIndexing", static_cast<bool>(obj.shaderSampledImageArrayDynamicIndexing));
+    p.PrintKeyBool("shaderStorageBufferArrayDynamicIndexing", static_cast<bool>(obj.shaderStorageBufferArrayDynamicIndexing));
+    p.PrintKeyBool("shaderStorageImageArrayDynamicIndexing", static_cast<bool>(obj.shaderStorageImageArrayDynamicIndexing));
+    p.PrintKeyBool("shaderClipDistance", static_cast<bool>(obj.shaderClipDistance));
+    p.PrintKeyBool("shaderCullDistance", static_cast<bool>(obj.shaderCullDistance));
+    p.PrintKeyBool("shaderFloat64", static_cast<bool>(obj.shaderFloat64));
+    p.PrintKeyBool("shaderInt64", static_cast<bool>(obj.shaderInt64));
+    p.PrintKeyBool("shaderInt16", static_cast<bool>(obj.shaderInt16));
+    p.PrintKeyBool("shaderResourceResidency", static_cast<bool>(obj.shaderResourceResidency));
+    p.PrintKeyBool("shaderResourceMinLod", static_cast<bool>(obj.shaderResourceMinLod));
+    p.PrintKeyBool("sparseBinding", static_cast<bool>(obj.sparseBinding));
+    p.PrintKeyBool("sparseResidencyBuffer", static_cast<bool>(obj.sparseResidencyBuffer));
+    p.PrintKeyBool("sparseResidencyImage2D", static_cast<bool>(obj.sparseResidencyImage2D));
+    p.PrintKeyBool("sparseResidencyImage3D", static_cast<bool>(obj.sparseResidencyImage3D));
+    p.PrintKeyBool("sparseResidency2Samples", static_cast<bool>(obj.sparseResidency2Samples));
+    p.PrintKeyBool("sparseResidency4Samples", static_cast<bool>(obj.sparseResidency4Samples));
+    p.PrintKeyBool("sparseResidency8Samples", static_cast<bool>(obj.sparseResidency8Samples));
+    p.PrintKeyBool("sparseResidency16Samples", static_cast<bool>(obj.sparseResidency16Samples));
+    p.PrintKeyBool("sparseResidencyAliased", static_cast<bool>(obj.sparseResidencyAliased));
+    p.PrintKeyBool("variableMultisampleRate", static_cast<bool>(obj.variableMultisampleRate));
+    p.PrintKeyBool("inheritedQueries", static_cast<bool>(obj.inheritedQueries));
+}
+void DumpVkPhysicalDeviceFloatControlsProperties(Printer &p, std::string name, const VkPhysicalDeviceFloatControlsProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(37);
+    DumpVkShaderFloatControlsIndependence(p, "denormBehaviorIndependence", obj.denormBehaviorIndependence);
+    DumpVkShaderFloatControlsIndependence(p, "roundingModeIndependence", obj.roundingModeIndependence);
+    p.PrintKeyBool("shaderSignedZeroInfNanPreserveFloat16", static_cast<bool>(obj.shaderSignedZeroInfNanPreserveFloat16));
+    p.PrintKeyBool("shaderSignedZeroInfNanPreserveFloat32", static_cast<bool>(obj.shaderSignedZeroInfNanPreserveFloat32));
+    p.PrintKeyBool("shaderSignedZeroInfNanPreserveFloat64", static_cast<bool>(obj.shaderSignedZeroInfNanPreserveFloat64));
+    p.PrintKeyBool("shaderDenormPreserveFloat16", static_cast<bool>(obj.shaderDenormPreserveFloat16));
+    p.PrintKeyBool("shaderDenormPreserveFloat32", static_cast<bool>(obj.shaderDenormPreserveFloat32));
+    p.PrintKeyBool("shaderDenormPreserveFloat64", static_cast<bool>(obj.shaderDenormPreserveFloat64));
+    p.PrintKeyBool("shaderDenormFlushToZeroFloat16", static_cast<bool>(obj.shaderDenormFlushToZeroFloat16));
+    p.PrintKeyBool("shaderDenormFlushToZeroFloat32", static_cast<bool>(obj.shaderDenormFlushToZeroFloat32));
+    p.PrintKeyBool("shaderDenormFlushToZeroFloat64", static_cast<bool>(obj.shaderDenormFlushToZeroFloat64));
+    p.PrintKeyBool("shaderRoundingModeRTEFloat16", static_cast<bool>(obj.shaderRoundingModeRTEFloat16));
+    p.PrintKeyBool("shaderRoundingModeRTEFloat32", static_cast<bool>(obj.shaderRoundingModeRTEFloat32));
+    p.PrintKeyBool("shaderRoundingModeRTEFloat64", static_cast<bool>(obj.shaderRoundingModeRTEFloat64));
+    p.PrintKeyBool("shaderRoundingModeRTZFloat16", static_cast<bool>(obj.shaderRoundingModeRTZFloat16));
+    p.PrintKeyBool("shaderRoundingModeRTZFloat32", static_cast<bool>(obj.shaderRoundingModeRTZFloat32));
+    p.PrintKeyBool("shaderRoundingModeRTZFloat64", static_cast<bool>(obj.shaderRoundingModeRTZFloat64));
+}
+void DumpVkPhysicalDeviceFragmentDensityMap2FeaturesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(26);
+    p.PrintKeyBool("fragmentDensityMapDeferred", static_cast<bool>(obj.fragmentDensityMapDeferred));
+}
+void DumpVkPhysicalDeviceFragmentDensityMap2PropertiesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(41);
+    p.PrintKeyBool("subsampledLoads", static_cast<bool>(obj.subsampledLoads));
+    p.PrintKeyBool("subsampledCoarseReconstructionEarlyAccess", static_cast<bool>(obj.subsampledCoarseReconstructionEarlyAccess));
+    p.PrintKeyValue("maxSubsampledArrayLayers", obj.maxSubsampledArrayLayers);
+    p.PrintKeyValue("maxDescriptorSetSubsampledSamplers", obj.maxDescriptorSetSubsampledSamplers);
+}
+void DumpVkPhysicalDeviceFragmentDensityMapFeaturesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceFragmentDensityMapFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(37);
+    p.PrintKeyBool("fragmentDensityMap", static_cast<bool>(obj.fragmentDensityMap));
+    p.PrintKeyBool("fragmentDensityMapDynamic", static_cast<bool>(obj.fragmentDensityMapDynamic));
+    p.PrintKeyBool("fragmentDensityMapNonSubsampledImages", static_cast<bool>(obj.fragmentDensityMapNonSubsampledImages));
+}
+void DumpVkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(24);
+    p.PrintKeyBool("fragmentDensityMapOffset", static_cast<bool>(obj.fragmentDensityMapOffset));
+}
+void DumpVkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkExtent2D(p, "fragmentDensityOffsetGranularity", obj.fragmentDensityOffsetGranularity);
+}
+void DumpVkPhysicalDeviceFragmentDensityMapPropertiesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceFragmentDensityMapPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(26);
+    DumpVkExtent2D(p, "minFragmentDensityTexelSize", obj.minFragmentDensityTexelSize);
+    DumpVkExtent2D(p, "maxFragmentDensityTexelSize", obj.maxFragmentDensityTexelSize);
+    p.PrintKeyBool("fragmentDensityInvocations", static_cast<bool>(obj.fragmentDensityInvocations));
+}
+void DumpVkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(Printer &p, std::string name,
+                                                              const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(25);
+    p.PrintKeyBool("fragmentShaderBarycentric", static_cast<bool>(obj.fragmentShaderBarycentric));
+}
+void DumpVkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(Printer &p, std::string name,
+                                                                const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(47);
+    p.PrintKeyBool("triStripVertexOrderIndependentOfProvokingVertex",
+                   static_cast<bool>(obj.triStripVertexOrderIndependentOfProvokingVertex));
+}
+void DumpVkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(34);
+    p.PrintKeyBool("fragmentShaderSampleInterlock", static_cast<bool>(obj.fragmentShaderSampleInterlock));
+    p.PrintKeyBool("fragmentShaderPixelInterlock", static_cast<bool>(obj.fragmentShaderPixelInterlock));
+    p.PrintKeyBool("fragmentShaderShadingRateInterlock", static_cast<bool>(obj.fragmentShaderShadingRateInterlock));
+}
+void DumpVkPhysicalDeviceFragmentShadingRateFeaturesKHR(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceFragmentShadingRateFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(29);
+    p.PrintKeyBool("pipelineFragmentShadingRate", static_cast<bool>(obj.pipelineFragmentShadingRate));
+    p.PrintKeyBool("primitiveFragmentShadingRate", static_cast<bool>(obj.primitiveFragmentShadingRate));
+    p.PrintKeyBool("attachmentFragmentShadingRate", static_cast<bool>(obj.attachmentFragmentShadingRate));
+}
+void DumpVkPhysicalDeviceFragmentShadingRateKHR(Printer &p, std::string name, const VkPhysicalDeviceFragmentShadingRateKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkSampleCountFlags(p, "sampleCounts", obj.sampleCounts);
+    DumpVkExtent2D(p, "fragmentSize", obj.fragmentSize);
+}
+void DumpVkPhysicalDeviceFragmentShadingRatePropertiesKHR(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceFragmentShadingRatePropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(52);
+    DumpVkExtent2D(p, "minFragmentShadingRateAttachmentTexelSize", obj.minFragmentShadingRateAttachmentTexelSize);
+    DumpVkExtent2D(p, "maxFragmentShadingRateAttachmentTexelSize", obj.maxFragmentShadingRateAttachmentTexelSize);
+    p.PrintKeyValue("maxFragmentShadingRateAttachmentTexelSizeAspectRatio",
+                    obj.maxFragmentShadingRateAttachmentTexelSizeAspectRatio);
+    p.PrintKeyBool("primitiveFragmentShadingRateWithMultipleViewports",
+                   static_cast<bool>(obj.primitiveFragmentShadingRateWithMultipleViewports));
+    p.PrintKeyBool("layeredShadingRateAttachments", static_cast<bool>(obj.layeredShadingRateAttachments));
+    p.PrintKeyBool("fragmentShadingRateNonTrivialCombinerOps", static_cast<bool>(obj.fragmentShadingRateNonTrivialCombinerOps));
+    DumpVkExtent2D(p, "maxFragmentSize", obj.maxFragmentSize);
+    p.PrintKeyValue("maxFragmentSizeAspectRatio", obj.maxFragmentSizeAspectRatio);
+    p.PrintKeyValue("maxFragmentShadingRateCoverageSamples", obj.maxFragmentShadingRateCoverageSamples);
+    DumpVkSampleCountFlagBits(p, "maxFragmentShadingRateRasterizationSamples", obj.maxFragmentShadingRateRasterizationSamples);
+    p.PrintKeyBool("fragmentShadingRateWithShaderDepthStencilWrites",
+                   static_cast<bool>(obj.fragmentShadingRateWithShaderDepthStencilWrites));
+    p.PrintKeyBool("fragmentShadingRateWithSampleMask", static_cast<bool>(obj.fragmentShadingRateWithSampleMask));
+    p.PrintKeyBool("fragmentShadingRateWithShaderSampleMask", static_cast<bool>(obj.fragmentShadingRateWithShaderSampleMask));
+    p.PrintKeyBool("fragmentShadingRateWithConservativeRasterization",
+                   static_cast<bool>(obj.fragmentShadingRateWithConservativeRasterization));
+    p.PrintKeyBool("fragmentShadingRateWithFragmentShaderInterlock",
+                   static_cast<bool>(obj.fragmentShadingRateWithFragmentShaderInterlock));
+    p.PrintKeyBool("fragmentShadingRateWithCustomSampleLocations",
+                   static_cast<bool>(obj.fragmentShadingRateWithCustomSampleLocations));
+    p.PrintKeyBool("fragmentShadingRateStrictMultiplyCombiner", static_cast<bool>(obj.fragmentShadingRateStrictMultiplyCombiner));
+}
+void DumpVkPhysicalDeviceFrameBoundaryFeaturesEXT(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceFrameBoundaryFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(13);
+    p.PrintKeyBool("frameBoundary", static_cast<bool>(obj.frameBoundary));
+}
+void DumpVkPhysicalDeviceGlobalPriorityQueryFeatures(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceGlobalPriorityQueryFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(19);
+    p.PrintKeyBool("globalPriorityQuery", static_cast<bool>(obj.globalPriorityQuery));
+}
+void DumpVkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(23);
+    p.PrintKeyBool("graphicsPipelineLibrary", static_cast<bool>(obj.graphicsPipelineLibrary));
+}
+void DumpVkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(Printer &p, std::string name,
+                                                              const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(57);
+    p.PrintKeyBool("graphicsPipelineLibraryFastLinking", static_cast<bool>(obj.graphicsPipelineLibraryFastLinking));
+    p.PrintKeyBool("graphicsPipelineLibraryIndependentInterpolationDecoration",
+                   static_cast<bool>(obj.graphicsPipelineLibraryIndependentInterpolationDecoration));
+}
+void DumpVkPhysicalDeviceHostImageCopyFeatures(Printer &p, std::string name, const VkPhysicalDeviceHostImageCopyFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(13);
+    p.PrintKeyBool("hostImageCopy", static_cast<bool>(obj.hostImageCopy));
+}
+void DumpVkPhysicalDeviceHostImageCopyProperties(Printer &p, std::string name, const VkPhysicalDeviceHostImageCopyProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(31);
+    p.PrintKeyValue("copySrcLayoutCount", obj.copySrcLayoutCount);
+    if (obj.copySrcLayoutCount == 0 || obj.pCopySrcLayouts == nullptr) {
+        p.PrintKeyString("pCopySrcLayouts", "NULL");
+    } else {
+        ArrayWrapper arr(p, "pCopySrcLayouts", obj.copySrcLayoutCount);
+        for (uint32_t i = 0; i < obj.copySrcLayoutCount; i++) {
+            DumpVkImageLayout(p, std::to_string(i), obj.pCopySrcLayouts[i]);
+        }
+    }
+    p.PrintKeyValue("copyDstLayoutCount", obj.copyDstLayoutCount);
+    if (obj.copyDstLayoutCount == 0 || obj.pCopyDstLayouts == nullptr) {
+        p.PrintKeyString("pCopyDstLayouts", "NULL");
+    } else {
+        ArrayWrapper arr(p, "pCopyDstLayouts", obj.copyDstLayoutCount);
+        for (uint32_t i = 0; i < obj.copyDstLayoutCount; i++) {
+            DumpVkImageLayout(p, std::to_string(i), obj.pCopyDstLayouts[i]);
+        }
+    }
+    p.PrintKeyValue("optimalTilingLayoutUUID", obj.optimalTilingLayoutUUID);
+    p.PrintKeyBool("identicalMemoryTypeRequirements", static_cast<bool>(obj.identicalMemoryTypeRequirements));
+}
+void DumpVkPhysicalDeviceHostQueryResetFeatures(Printer &p, std::string name, const VkPhysicalDeviceHostQueryResetFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(14);
+    p.PrintKeyBool("hostQueryReset", static_cast<bool>(obj.hostQueryReset));
+}
+void DumpVkPhysicalDeviceIDProperties(Printer &p, std::string name, const VkPhysicalDeviceIDProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(15);
+    p.PrintKeyValue("deviceUUID", obj.deviceUUID);
+    p.PrintKeyValue("driverUUID", obj.driverUUID);
+    if (obj.deviceLUIDValid) {  // special case
+        p.PrintKeyValue("deviceLUID", obj.deviceLUID);
+    }
+    p.PrintKeyValue("deviceNodeMask", obj.deviceNodeMask);
+    p.PrintKeyBool("deviceLUIDValid", static_cast<bool>(obj.deviceLUIDValid));
+}
+void DumpVkPhysicalDeviceImage2DViewOf3DFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyBool("image2DViewOf3D", static_cast<bool>(obj.image2DViewOf3D));
+    p.PrintKeyBool("sampler2DViewOf3D", static_cast<bool>(obj.sampler2DViewOf3D));
+}
+void DumpVkPhysicalDeviceImageCompressionControlFeaturesEXT(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceImageCompressionControlFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(23);
+    p.PrintKeyBool("imageCompressionControl", static_cast<bool>(obj.imageCompressionControl));
+}
+void DumpVkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(32);
+    p.PrintKeyBool("imageCompressionControlSwapchain", static_cast<bool>(obj.imageCompressionControlSwapchain));
+}
+void DumpVkPhysicalDeviceImageRobustnessFeatures(Printer &p, std::string name, const VkPhysicalDeviceImageRobustnessFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyBool("robustImageAccess", static_cast<bool>(obj.robustImageAccess));
+}
+void DumpVkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(19);
+    p.PrintKeyBool("imageSlicedViewOf3D", static_cast<bool>(obj.imageSlicedViewOf3D));
+}
+void DumpVkPhysicalDeviceImageViewMinLodFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceImageViewMinLodFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(6);
+    p.PrintKeyBool("minLod", static_cast<bool>(obj.minLod));
+}
+void DumpVkPhysicalDeviceImagelessFramebufferFeatures(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceImagelessFramebufferFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(20);
+    p.PrintKeyBool("imagelessFramebuffer", static_cast<bool>(obj.imagelessFramebuffer));
+}
+void DumpVkPhysicalDeviceIndexTypeUint8Features(Printer &p, std::string name, const VkPhysicalDeviceIndexTypeUint8Features &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(14);
+    p.PrintKeyBool("indexTypeUint8", static_cast<bool>(obj.indexTypeUint8));
+}
+void DumpVkPhysicalDeviceInlineUniformBlockFeatures(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceInlineUniformBlockFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(50);
+    p.PrintKeyBool("inlineUniformBlock", static_cast<bool>(obj.inlineUniformBlock));
+    p.PrintKeyBool("descriptorBindingInlineUniformBlockUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingInlineUniformBlockUpdateAfterBind));
+}
+void DumpVkPhysicalDeviceInlineUniformBlockProperties(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceInlineUniformBlockProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(55);
+    p.PrintKeyValue("maxInlineUniformBlockSize", obj.maxInlineUniformBlockSize);
+    p.PrintKeyValue("maxPerStageDescriptorInlineUniformBlocks", obj.maxPerStageDescriptorInlineUniformBlocks);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks",
+                    obj.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks);
+    p.PrintKeyValue("maxDescriptorSetInlineUniformBlocks", obj.maxDescriptorSetInlineUniformBlocks);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindInlineUniformBlocks", obj.maxDescriptorSetUpdateAfterBindInlineUniformBlocks);
+}
+void DumpVkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR(
+    Printer &p, std::string name, const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(28);
+    p.PrintKeyBool("internallySynchronizedQueues", static_cast<bool>(obj.internallySynchronizedQueues));
+}
+void DumpVkPhysicalDeviceLayeredApiPropertiesKHR(Printer &p, std::string name, const VkPhysicalDeviceLayeredApiPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(10);
+    p.PrintKeyValue("vendorID", to_hex_str(p, obj.vendorID));
+    p.PrintKeyValue("deviceID", to_hex_str(p, obj.deviceID));
+    DumpVkPhysicalDeviceLayeredApiKHR(p, "layeredAPI", obj.layeredAPI);
+    p.PrintKeyString("deviceName", obj.deviceName);
+}
+void DumpVkPhysicalDeviceLayeredApiPropertiesListKHR(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceLayeredApiPropertiesListKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(15);
+    p.PrintKeyValue("layeredApiCount", obj.layeredApiCount);
+    if (obj.layeredApiCount == 0 || obj.pLayeredApis == nullptr) {
+        p.PrintKeyString("pLayeredApis", "NULL");
+    } else {
+        ArrayWrapper arr(p, "pLayeredApis", obj.layeredApiCount);
+        for (uint32_t i = 0; i < obj.layeredApiCount; i++) {
+            DumpVkPhysicalDeviceLayeredApiPropertiesKHR(p, std::to_string(i), obj.pLayeredApis[i]);
+        }
+    }
+}
+void DumpVkPhysicalDeviceLegacyDitheringFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceLegacyDitheringFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(15);
+    p.PrintKeyBool("legacyDithering", static_cast<bool>(obj.legacyDithering));
+}
+void DumpVkPhysicalDeviceLegacyVertexAttributesFeaturesEXT(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(22);
+    p.PrintKeyBool("legacyVertexAttributes", static_cast<bool>(obj.legacyVertexAttributes));
+}
+void DumpVkPhysicalDeviceLegacyVertexAttributesPropertiesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(26);
+    p.PrintKeyBool("nativeUnalignedPerformance", static_cast<bool>(obj.nativeUnalignedPerformance));
+}
+void DumpVkPhysicalDeviceLimits(Printer &p, std::string name, const VkPhysicalDeviceLimits &obj) {
+    if (p.Type() == OutputType::json)
+        p.ObjectStart("limits");
+    else
+        p.SetSubHeader().ObjectStart(name);
+    p.SetMinKeyWidth(47);
+    p.PrintKeyValue("maxImageDimension1D", obj.maxImageDimension1D);
+    p.PrintKeyValue("maxImageDimension2D", obj.maxImageDimension2D);
+    p.PrintKeyValue("maxImageDimension3D", obj.maxImageDimension3D);
+    p.PrintKeyValue("maxImageDimensionCube", obj.maxImageDimensionCube);
+    p.PrintKeyValue("maxImageArrayLayers", obj.maxImageArrayLayers);
+    p.PrintKeyValue("maxTexelBufferElements", obj.maxTexelBufferElements);
+    p.PrintKeyValue("maxUniformBufferRange", obj.maxUniformBufferRange);
+    p.PrintKeyValue("maxStorageBufferRange", obj.maxStorageBufferRange);
+    p.PrintKeyValue("maxPushConstantsSize", obj.maxPushConstantsSize);
+    p.PrintKeyValue("maxMemoryAllocationCount", obj.maxMemoryAllocationCount);
+    p.PrintKeyValue("maxSamplerAllocationCount", obj.maxSamplerAllocationCount);
+    p.PrintKeyValue("bufferImageGranularity", to_hex_str(p, obj.bufferImageGranularity));
+    p.PrintKeyValue("sparseAddressSpaceSize", to_hex_str(p, obj.sparseAddressSpaceSize));
+    p.PrintKeyValue("maxBoundDescriptorSets", obj.maxBoundDescriptorSets);
+    p.PrintKeyValue("maxPerStageDescriptorSamplers", obj.maxPerStageDescriptorSamplers);
+    p.PrintKeyValue("maxPerStageDescriptorUniformBuffers", obj.maxPerStageDescriptorUniformBuffers);
+    p.PrintKeyValue("maxPerStageDescriptorStorageBuffers", obj.maxPerStageDescriptorStorageBuffers);
+    p.PrintKeyValue("maxPerStageDescriptorSampledImages", obj.maxPerStageDescriptorSampledImages);
+    p.PrintKeyValue("maxPerStageDescriptorStorageImages", obj.maxPerStageDescriptorStorageImages);
+    p.PrintKeyValue("maxPerStageDescriptorInputAttachments", obj.maxPerStageDescriptorInputAttachments);
+    p.PrintKeyValue("maxPerStageResources", obj.maxPerStageResources);
+    p.PrintKeyValue("maxDescriptorSetSamplers", obj.maxDescriptorSetSamplers);
+    p.PrintKeyValue("maxDescriptorSetUniformBuffers", obj.maxDescriptorSetUniformBuffers);
+    p.PrintKeyValue("maxDescriptorSetUniformBuffersDynamic", obj.maxDescriptorSetUniformBuffersDynamic);
+    p.PrintKeyValue("maxDescriptorSetStorageBuffers", obj.maxDescriptorSetStorageBuffers);
+    p.PrintKeyValue("maxDescriptorSetStorageBuffersDynamic", obj.maxDescriptorSetStorageBuffersDynamic);
+    p.PrintKeyValue("maxDescriptorSetSampledImages", obj.maxDescriptorSetSampledImages);
+    p.PrintKeyValue("maxDescriptorSetStorageImages", obj.maxDescriptorSetStorageImages);
+    p.PrintKeyValue("maxDescriptorSetInputAttachments", obj.maxDescriptorSetInputAttachments);
+    p.PrintKeyValue("maxVertexInputAttributes", obj.maxVertexInputAttributes);
+    p.PrintKeyValue("maxVertexInputBindings", obj.maxVertexInputBindings);
+    p.PrintKeyValue("maxVertexInputAttributeOffset", obj.maxVertexInputAttributeOffset);
+    p.PrintKeyValue("maxVertexInputBindingStride", obj.maxVertexInputBindingStride);
+    p.PrintKeyValue("maxVertexOutputComponents", obj.maxVertexOutputComponents);
+    p.PrintKeyValue("maxTessellationGenerationLevel", obj.maxTessellationGenerationLevel);
+    p.PrintKeyValue("maxTessellationPatchSize", obj.maxTessellationPatchSize);
+    p.PrintKeyValue("maxTessellationControlPerVertexInputComponents", obj.maxTessellationControlPerVertexInputComponents);
+    p.PrintKeyValue("maxTessellationControlPerVertexOutputComponents", obj.maxTessellationControlPerVertexOutputComponents);
+    p.PrintKeyValue("maxTessellationControlPerPatchOutputComponents", obj.maxTessellationControlPerPatchOutputComponents);
+    p.PrintKeyValue("maxTessellationControlTotalOutputComponents", obj.maxTessellationControlTotalOutputComponents);
+    p.PrintKeyValue("maxTessellationEvaluationInputComponents", obj.maxTessellationEvaluationInputComponents);
+    p.PrintKeyValue("maxTessellationEvaluationOutputComponents", obj.maxTessellationEvaluationOutputComponents);
+    p.PrintKeyValue("maxGeometryShaderInvocations", obj.maxGeometryShaderInvocations);
+    p.PrintKeyValue("maxGeometryInputComponents", obj.maxGeometryInputComponents);
+    p.PrintKeyValue("maxGeometryOutputComponents", obj.maxGeometryOutputComponents);
+    p.PrintKeyValue("maxGeometryOutputVertices", obj.maxGeometryOutputVertices);
+    p.PrintKeyValue("maxGeometryTotalOutputComponents", obj.maxGeometryTotalOutputComponents);
+    p.PrintKeyValue("maxFragmentInputComponents", obj.maxFragmentInputComponents);
+    p.PrintKeyValue("maxFragmentOutputAttachments", obj.maxFragmentOutputAttachments);
+    p.PrintKeyValue("maxFragmentDualSrcAttachments", obj.maxFragmentDualSrcAttachments);
+    p.PrintKeyValue("maxFragmentCombinedOutputResources", obj.maxFragmentCombinedOutputResources);
+    p.PrintKeyValue("maxComputeSharedMemorySize", obj.maxComputeSharedMemorySize);
+    {
+        ArrayWrapper arr(p, "maxComputeWorkGroupCount", 3);
+        for (uint32_t i = 0; i < 3; i++) {
+            p.PrintElement(obj.maxComputeWorkGroupCount[i]);
+        }
+    }
+    p.PrintKeyValue("maxComputeWorkGroupInvocations", obj.maxComputeWorkGroupInvocations);
+    {
+        ArrayWrapper arr(p, "maxComputeWorkGroupSize", 3);
+        for (uint32_t i = 0; i < 3; i++) {
+            p.PrintElement(obj.maxComputeWorkGroupSize[i]);
+        }
+    }
+    p.PrintKeyValue("subPixelPrecisionBits", obj.subPixelPrecisionBits);
+    p.PrintKeyValue("subTexelPrecisionBits", obj.subTexelPrecisionBits);
+    p.PrintKeyValue("mipmapPrecisionBits", obj.mipmapPrecisionBits);
+    p.PrintKeyValue("maxDrawIndexedIndexValue", obj.maxDrawIndexedIndexValue);
+    p.PrintKeyValue("maxDrawIndirectCount", obj.maxDrawIndirectCount);
+    p.PrintKeyValue("maxSamplerLodBias", obj.maxSamplerLodBias);
+    p.PrintKeyValue("maxSamplerAnisotropy", obj.maxSamplerAnisotropy);
+    p.PrintKeyValue("maxViewports", obj.maxViewports);
+    {
+        ArrayWrapper arr(p, "maxViewportDimensions", 2);
+        for (uint32_t i = 0; i < 2; i++) {
+            p.PrintElement(obj.maxViewportDimensions[i]);
+        }
+    }
+    {
+        ArrayWrapper arr(p, "viewportBoundsRange", 2);
+        for (uint32_t i = 0; i < 2; i++) {
+            p.PrintElement(obj.viewportBoundsRange[i]);
+        }
+    }
+    p.PrintKeyValue("viewportSubPixelBits", obj.viewportSubPixelBits);
+    p.PrintKeyValue("minMemoryMapAlignment", obj.minMemoryMapAlignment);
+    p.PrintKeyValue("minTexelBufferOffsetAlignment", to_hex_str(p, obj.minTexelBufferOffsetAlignment));
+    p.PrintKeyValue("minUniformBufferOffsetAlignment", to_hex_str(p, obj.minUniformBufferOffsetAlignment));
+    p.PrintKeyValue("minStorageBufferOffsetAlignment", to_hex_str(p, obj.minStorageBufferOffsetAlignment));
+    p.PrintKeyValue("minTexelOffset", obj.minTexelOffset);
+    p.PrintKeyValue("maxTexelOffset", obj.maxTexelOffset);
+    p.PrintKeyValue("minTexelGatherOffset", obj.minTexelGatherOffset);
+    p.PrintKeyValue("maxTexelGatherOffset", obj.maxTexelGatherOffset);
+    p.PrintKeyValue("minInterpolationOffset", obj.minInterpolationOffset);
+    p.PrintKeyValue("maxInterpolationOffset", obj.maxInterpolationOffset);
+    p.PrintKeyValue("subPixelInterpolationOffsetBits", obj.subPixelInterpolationOffsetBits);
+    p.PrintKeyValue("maxFramebufferWidth", obj.maxFramebufferWidth);
+    p.PrintKeyValue("maxFramebufferHeight", obj.maxFramebufferHeight);
+    p.PrintKeyValue("maxFramebufferLayers", obj.maxFramebufferLayers);
+    DumpVkSampleCountFlags(p, "framebufferColorSampleCounts", obj.framebufferColorSampleCounts);
+    DumpVkSampleCountFlags(p, "framebufferDepthSampleCounts", obj.framebufferDepthSampleCounts);
+    DumpVkSampleCountFlags(p, "framebufferStencilSampleCounts", obj.framebufferStencilSampleCounts);
+    DumpVkSampleCountFlags(p, "framebufferNoAttachmentsSampleCounts", obj.framebufferNoAttachmentsSampleCounts);
+    p.PrintKeyValue("maxColorAttachments", obj.maxColorAttachments);
+    DumpVkSampleCountFlags(p, "sampledImageColorSampleCounts", obj.sampledImageColorSampleCounts);
+    DumpVkSampleCountFlags(p, "sampledImageIntegerSampleCounts", obj.sampledImageIntegerSampleCounts);
+    DumpVkSampleCountFlags(p, "sampledImageDepthSampleCounts", obj.sampledImageDepthSampleCounts);
+    DumpVkSampleCountFlags(p, "sampledImageStencilSampleCounts", obj.sampledImageStencilSampleCounts);
+    DumpVkSampleCountFlags(p, "storageImageSampleCounts", obj.storageImageSampleCounts);
+    p.PrintKeyValue("maxSampleMaskWords", obj.maxSampleMaskWords);
+    p.PrintKeyBool("timestampComputeAndGraphics", static_cast<bool>(obj.timestampComputeAndGraphics));
+    p.PrintKeyValue("timestampPeriod", obj.timestampPeriod);
+    p.PrintKeyValue("maxClipDistances", obj.maxClipDistances);
+    p.PrintKeyValue("maxCullDistances", obj.maxCullDistances);
+    p.PrintKeyValue("maxCombinedClipAndCullDistances", obj.maxCombinedClipAndCullDistances);
+    p.PrintKeyValue("discreteQueuePriorities", obj.discreteQueuePriorities);
+    {
+        ArrayWrapper arr(p, "pointSizeRange", 2);
+        for (uint32_t i = 0; i < 2; i++) {
+            p.PrintElement(obj.pointSizeRange[i]);
+        }
+    }
+    {
+        ArrayWrapper arr(p, "lineWidthRange", 2);
+        for (uint32_t i = 0; i < 2; i++) {
+            p.PrintElement(obj.lineWidthRange[i]);
+        }
+    }
+    p.PrintKeyValue("pointSizeGranularity", obj.pointSizeGranularity);
+    p.PrintKeyValue("lineWidthGranularity", obj.lineWidthGranularity);
+    p.PrintKeyBool("strictLines", static_cast<bool>(obj.strictLines));
+    p.PrintKeyBool("standardSampleLocations", static_cast<bool>(obj.standardSampleLocations));
+    p.PrintKeyValue("optimalBufferCopyOffsetAlignment", to_hex_str(p, obj.optimalBufferCopyOffsetAlignment));
+    p.PrintKeyValue("optimalBufferCopyRowPitchAlignment", to_hex_str(p, obj.optimalBufferCopyRowPitchAlignment));
+    p.PrintKeyValue("nonCoherentAtomSize", to_hex_str(p, obj.nonCoherentAtomSize));
+    p.ObjectEnd();
+}
+void DumpVkPhysicalDeviceLineRasterizationFeatures(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceLineRasterizationFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(24);
+    p.PrintKeyBool("rectangularLines", static_cast<bool>(obj.rectangularLines));
+    p.PrintKeyBool("bresenhamLines", static_cast<bool>(obj.bresenhamLines));
+    p.PrintKeyBool("smoothLines", static_cast<bool>(obj.smoothLines));
+    p.PrintKeyBool("stippledRectangularLines", static_cast<bool>(obj.stippledRectangularLines));
+    p.PrintKeyBool("stippledBresenhamLines", static_cast<bool>(obj.stippledBresenhamLines));
+    p.PrintKeyBool("stippledSmoothLines", static_cast<bool>(obj.stippledSmoothLines));
+}
+void DumpVkPhysicalDeviceLineRasterizationProperties(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceLineRasterizationProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(25);
+    p.PrintKeyValue("lineSubPixelPrecisionBits", obj.lineSubPixelPrecisionBits);
+}
+void DumpVkPhysicalDeviceMaintenance10FeaturesKHR(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceMaintenance10FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(13);
+    p.PrintKeyBool("maintenance10", static_cast<bool>(obj.maintenance10));
+}
+void DumpVkPhysicalDeviceMaintenance10PropertiesKHR(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceMaintenance10PropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(48);
+    p.PrintKeyBool("rgba4OpaqueBlackSwizzled", static_cast<bool>(obj.rgba4OpaqueBlackSwizzled));
+    p.PrintKeyBool("resolveSrgbFormatAppliesTransferFunction", static_cast<bool>(obj.resolveSrgbFormatAppliesTransferFunction));
+    p.PrintKeyBool("resolveSrgbFormatSupportsTransferFunctionControl",
+                   static_cast<bool>(obj.resolveSrgbFormatSupportsTransferFunctionControl));
+}
+void DumpVkPhysicalDeviceMaintenance3Properties(Printer &p, std::string name, const VkPhysicalDeviceMaintenance3Properties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(23);
+    p.PrintKeyValue("maxPerSetDescriptors", obj.maxPerSetDescriptors);
+    p.PrintKeyValue("maxMemoryAllocationSize", to_hex_str(p, obj.maxMemoryAllocationSize));
+}
+void DumpVkPhysicalDeviceMaintenance4Features(Printer &p, std::string name, const VkPhysicalDeviceMaintenance4Features &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(12);
+    p.PrintKeyBool("maintenance4", static_cast<bool>(obj.maintenance4));
+}
+void DumpVkPhysicalDeviceMaintenance4Properties(Printer &p, std::string name, const VkPhysicalDeviceMaintenance4Properties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(13);
+    p.PrintKeyValue("maxBufferSize", to_hex_str(p, obj.maxBufferSize));
+}
+void DumpVkPhysicalDeviceMaintenance5Features(Printer &p, std::string name, const VkPhysicalDeviceMaintenance5Features &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(12);
+    p.PrintKeyBool("maintenance5", static_cast<bool>(obj.maintenance5));
+}
+void DumpVkPhysicalDeviceMaintenance5Properties(Printer &p, std::string name, const VkPhysicalDeviceMaintenance5Properties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(51);
+    p.PrintKeyBool("earlyFragmentMultisampleCoverageAfterSampleCounting",
+                   static_cast<bool>(obj.earlyFragmentMultisampleCoverageAfterSampleCounting));
+    p.PrintKeyBool("earlyFragmentSampleMaskTestBeforeSampleCounting",
+                   static_cast<bool>(obj.earlyFragmentSampleMaskTestBeforeSampleCounting));
+    p.PrintKeyBool("depthStencilSwizzleOneSupport", static_cast<bool>(obj.depthStencilSwizzleOneSupport));
+    p.PrintKeyBool("polygonModePointSize", static_cast<bool>(obj.polygonModePointSize));
+    p.PrintKeyBool("nonStrictSinglePixelWideLinesUseParallelogram",
+                   static_cast<bool>(obj.nonStrictSinglePixelWideLinesUseParallelogram));
+    p.PrintKeyBool("nonStrictWideLinesUseParallelogram", static_cast<bool>(obj.nonStrictWideLinesUseParallelogram));
+}
+void DumpVkPhysicalDeviceMaintenance6Features(Printer &p, std::string name, const VkPhysicalDeviceMaintenance6Features &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(12);
+    p.PrintKeyBool("maintenance6", static_cast<bool>(obj.maintenance6));
+}
+void DumpVkPhysicalDeviceMaintenance6Properties(Printer &p, std::string name, const VkPhysicalDeviceMaintenance6Properties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(38);
+    p.PrintKeyBool("blockTexelViewCompatibleMultipleLayers", static_cast<bool>(obj.blockTexelViewCompatibleMultipleLayers));
+    p.PrintKeyValue("maxCombinedImageSamplerDescriptorCount", obj.maxCombinedImageSamplerDescriptorCount);
+    p.PrintKeyBool("fragmentShadingRateClampCombinerInputs", static_cast<bool>(obj.fragmentShadingRateClampCombinerInputs));
+}
+void DumpVkPhysicalDeviceMaintenance7FeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceMaintenance7FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(12);
+    p.PrintKeyBool("maintenance7", static_cast<bool>(obj.maintenance7));
+}
+void DumpVkPhysicalDeviceMaintenance7PropertiesKHR(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceMaintenance7PropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(57);
+    p.PrintKeyBool("robustFragmentShadingRateAttachmentAccess", static_cast<bool>(obj.robustFragmentShadingRateAttachmentAccess));
+    p.PrintKeyBool("separateDepthStencilAttachmentAccess", static_cast<bool>(obj.separateDepthStencilAttachmentAccess));
+    p.PrintKeyValue("maxDescriptorSetTotalUniformBuffersDynamic", obj.maxDescriptorSetTotalUniformBuffersDynamic);
+    p.PrintKeyValue("maxDescriptorSetTotalStorageBuffersDynamic", obj.maxDescriptorSetTotalStorageBuffersDynamic);
+    p.PrintKeyValue("maxDescriptorSetTotalBuffersDynamic", obj.maxDescriptorSetTotalBuffersDynamic);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic",
+                    obj.maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic",
+                    obj.maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindTotalBuffersDynamic", obj.maxDescriptorSetUpdateAfterBindTotalBuffersDynamic);
+}
+void DumpVkPhysicalDeviceMaintenance8FeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceMaintenance8FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(12);
+    p.PrintKeyBool("maintenance8", static_cast<bool>(obj.maintenance8));
+}
+void DumpVkPhysicalDeviceMaintenance9FeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceMaintenance9FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(12);
+    p.PrintKeyBool("maintenance9", static_cast<bool>(obj.maintenance9));
+}
+void DumpVkPhysicalDeviceMaintenance9PropertiesKHR(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceMaintenance9PropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(21);
+    p.PrintKeyBool("image2DViewOf3DSparse", static_cast<bool>(obj.image2DViewOf3DSparse));
+    DumpVkDefaultVertexAttributeValueKHR(p, "defaultVertexAttributeValue", obj.defaultVertexAttributeValue);
+}
+void DumpVkPhysicalDeviceMapMemoryPlacedFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(20);
+    p.PrintKeyBool("memoryMapPlaced", static_cast<bool>(obj.memoryMapPlaced));
+    p.PrintKeyBool("memoryMapRangePlaced", static_cast<bool>(obj.memoryMapRangePlaced));
+    p.PrintKeyBool("memoryUnmapReserve", static_cast<bool>(obj.memoryUnmapReserve));
+}
+void DumpVkPhysicalDeviceMapMemoryPlacedPropertiesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(27);
+    p.PrintKeyValue("minPlacedMemoryMapAlignment", to_hex_str(p, obj.minPlacedMemoryMapAlignment));
+}
+void DumpVkPhysicalDeviceMemoryBudgetPropertiesEXT(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceMemoryBudgetPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    {
+        ArrayWrapper arr(p, "heapBudget", VK_MAX_MEMORY_HEAPS);
+        for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++) {
+            p.PrintElement(obj.heapBudget[i]);
+        }
+    }
+    {
+        ArrayWrapper arr(p, "heapUsage", VK_MAX_MEMORY_HEAPS);
+        for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++) {
+            p.PrintElement(obj.heapUsage[i]);
+        }
+    }
+}
+void DumpVkPhysicalDeviceMemoryDecompressionFeaturesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceMemoryDecompressionFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(19);
+    p.PrintKeyBool("memoryDecompression", static_cast<bool>(obj.memoryDecompression));
+}
+void DumpVkPhysicalDeviceMemoryDecompressionPropertiesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceMemoryDecompressionPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(29);
+    DumpVkMemoryDecompressionMethodFlagsEXT(p, "decompressionMethods", obj.decompressionMethods);
+    p.PrintKeyValue("maxDecompressionIndirectCount", obj.maxDecompressionIndirectCount);
+}
+void DumpVkPhysicalDeviceMemoryPriorityFeaturesEXT(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceMemoryPriorityFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(14);
+    p.PrintKeyBool("memoryPriority", static_cast<bool>(obj.memoryPriority));
+}
+void DumpVkPhysicalDeviceMeshShaderFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceMeshShaderFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(38);
+    p.PrintKeyBool("taskShader", static_cast<bool>(obj.taskShader));
+    p.PrintKeyBool("meshShader", static_cast<bool>(obj.meshShader));
+    p.PrintKeyBool("multiviewMeshShader", static_cast<bool>(obj.multiviewMeshShader));
+    p.PrintKeyBool("primitiveFragmentShadingRateMeshShader", static_cast<bool>(obj.primitiveFragmentShadingRateMeshShader));
+    p.PrintKeyBool("meshShaderQueries", static_cast<bool>(obj.meshShaderQueries));
+}
+void DumpVkPhysicalDeviceMeshShaderPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceMeshShaderPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(37);
+    p.PrintKeyValue("maxTaskWorkGroupTotalCount", obj.maxTaskWorkGroupTotalCount);
+    {
+        ArrayWrapper arr(p, "maxTaskWorkGroupCount", 3);
+        for (uint32_t i = 0; i < 3; i++) {
+            p.PrintElement(obj.maxTaskWorkGroupCount[i]);
+        }
+    }
+    p.PrintKeyValue("maxTaskWorkGroupInvocations", obj.maxTaskWorkGroupInvocations);
+    {
+        ArrayWrapper arr(p, "maxTaskWorkGroupSize", 3);
+        for (uint32_t i = 0; i < 3; i++) {
+            p.PrintElement(obj.maxTaskWorkGroupSize[i]);
+        }
+    }
+    p.PrintKeyValue("maxTaskPayloadSize", obj.maxTaskPayloadSize);
+    p.PrintKeyValue("maxTaskSharedMemorySize", obj.maxTaskSharedMemorySize);
+    p.PrintKeyValue("maxTaskPayloadAndSharedMemorySize", obj.maxTaskPayloadAndSharedMemorySize);
+    p.PrintKeyValue("maxMeshWorkGroupTotalCount", obj.maxMeshWorkGroupTotalCount);
+    {
+        ArrayWrapper arr(p, "maxMeshWorkGroupCount", 3);
+        for (uint32_t i = 0; i < 3; i++) {
+            p.PrintElement(obj.maxMeshWorkGroupCount[i]);
+        }
+    }
+    p.PrintKeyValue("maxMeshWorkGroupInvocations", obj.maxMeshWorkGroupInvocations);
+    {
+        ArrayWrapper arr(p, "maxMeshWorkGroupSize", 3);
+        for (uint32_t i = 0; i < 3; i++) {
+            p.PrintElement(obj.maxMeshWorkGroupSize[i]);
+        }
+    }
+    p.PrintKeyValue("maxMeshSharedMemorySize", obj.maxMeshSharedMemorySize);
+    p.PrintKeyValue("maxMeshPayloadAndSharedMemorySize", obj.maxMeshPayloadAndSharedMemorySize);
+    p.PrintKeyValue("maxMeshOutputMemorySize", obj.maxMeshOutputMemorySize);
+    p.PrintKeyValue("maxMeshPayloadAndOutputMemorySize", obj.maxMeshPayloadAndOutputMemorySize);
+    p.PrintKeyValue("maxMeshOutputComponents", obj.maxMeshOutputComponents);
+    p.PrintKeyValue("maxMeshOutputVertices", obj.maxMeshOutputVertices);
+    p.PrintKeyValue("maxMeshOutputPrimitives", obj.maxMeshOutputPrimitives);
+    p.PrintKeyValue("maxMeshOutputLayers", obj.maxMeshOutputLayers);
+    p.PrintKeyValue("maxMeshMultiviewViewCount", obj.maxMeshMultiviewViewCount);
+    p.PrintKeyValue("meshOutputPerVertexGranularity", obj.meshOutputPerVertexGranularity);
+    p.PrintKeyValue("meshOutputPerPrimitiveGranularity", obj.meshOutputPerPrimitiveGranularity);
+    p.PrintKeyValue("maxPreferredTaskWorkGroupInvocations", obj.maxPreferredTaskWorkGroupInvocations);
+    p.PrintKeyValue("maxPreferredMeshWorkGroupInvocations", obj.maxPreferredMeshWorkGroupInvocations);
+    p.PrintKeyBool("prefersLocalInvocationVertexOutput", static_cast<bool>(obj.prefersLocalInvocationVertexOutput));
+    p.PrintKeyBool("prefersLocalInvocationPrimitiveOutput", static_cast<bool>(obj.prefersLocalInvocationPrimitiveOutput));
+    p.PrintKeyBool("prefersCompactVertexOutput", static_cast<bool>(obj.prefersCompactVertexOutput));
+    p.PrintKeyBool("prefersCompactPrimitiveOutput", static_cast<bool>(obj.prefersCompactPrimitiveOutput));
+}
+void DumpVkPhysicalDeviceMultiDrawFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceMultiDrawFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(9);
+    p.PrintKeyBool("multiDraw", static_cast<bool>(obj.multiDraw));
+}
+void DumpVkPhysicalDeviceMultiDrawPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceMultiDrawPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyValue("maxMultiDrawCount", obj.maxMultiDrawCount);
+}
+void DumpVkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(33);
+    p.PrintKeyBool("multisampledRenderToSingleSampled", static_cast<bool>(obj.multisampledRenderToSingleSampled));
+}
+void DumpVkPhysicalDeviceMultiviewFeatures(Printer &p, std::string name, const VkPhysicalDeviceMultiviewFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(27);
+    p.PrintKeyBool("multiview", static_cast<bool>(obj.multiview));
+    p.PrintKeyBool("multiviewGeometryShader", static_cast<bool>(obj.multiviewGeometryShader));
+    p.PrintKeyBool("multiviewTessellationShader", static_cast<bool>(obj.multiviewTessellationShader));
+}
+void DumpVkPhysicalDeviceMultiviewProperties(Printer &p, std::string name, const VkPhysicalDeviceMultiviewProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(25);
+    p.PrintKeyValue("maxMultiviewViewCount", obj.maxMultiviewViewCount);
+    p.PrintKeyValue("maxMultiviewInstanceIndex", obj.maxMultiviewInstanceIndex);
+}
+void DumpVkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(21);
+    p.PrintKeyBool("mutableDescriptorType", static_cast<bool>(obj.mutableDescriptorType));
+}
+void DumpVkPhysicalDeviceNestedCommandBufferFeaturesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceNestedCommandBufferFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(34);
+    p.PrintKeyBool("nestedCommandBuffer", static_cast<bool>(obj.nestedCommandBuffer));
+    p.PrintKeyBool("nestedCommandBufferRendering", static_cast<bool>(obj.nestedCommandBufferRendering));
+    p.PrintKeyBool("nestedCommandBufferSimultaneousUse", static_cast<bool>(obj.nestedCommandBufferSimultaneousUse));
+}
+void DumpVkPhysicalDeviceNestedCommandBufferPropertiesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceNestedCommandBufferPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(28);
+    p.PrintKeyValue("maxCommandBufferNestingLevel", obj.maxCommandBufferNestingLevel);
+}
+void DumpVkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(18);
+    p.PrintKeyBool("nonSeamlessCubeMap", static_cast<bool>(obj.nonSeamlessCubeMap));
+}
+void DumpVkPhysicalDeviceOpacityMicromapFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceOpacityMicromapFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(21);
+    p.PrintKeyBool("micromap", static_cast<bool>(obj.micromap));
+    p.PrintKeyBool("micromapCaptureReplay", static_cast<bool>(obj.micromapCaptureReplay));
+    p.PrintKeyBool("micromapHostCommands", static_cast<bool>(obj.micromapHostCommands));
+}
+void DumpVkPhysicalDeviceOpacityMicromapPropertiesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceOpacityMicromapPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(32);
+    p.PrintKeyValue("maxOpacity2StateSubdivisionLevel", obj.maxOpacity2StateSubdivisionLevel);
+    p.PrintKeyValue("maxOpacity4StateSubdivisionLevel", obj.maxOpacity4StateSubdivisionLevel);
+}
+void DumpVkPhysicalDevicePCIBusInfoPropertiesEXT(Printer &p, std::string name, const VkPhysicalDevicePCIBusInfoPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(11);
+    p.PrintKeyValue("pciDomain", obj.pciDomain);
+    p.PrintKeyValue("pciBus", obj.pciBus);
+    p.PrintKeyValue("pciDevice", obj.pciDevice);
+    p.PrintKeyValue("pciFunction", obj.pciFunction);
+}
+void DumpVkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(Printer &p, std::string name,
+                                                              const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(25);
+    p.PrintKeyBool("pageableDeviceLocalMemory", static_cast<bool>(obj.pageableDeviceLocalMemory));
+}
+void DumpVkPhysicalDevicePerformanceQueryFeaturesKHR(Printer &p, std::string name,
+                                                     const VkPhysicalDevicePerformanceQueryFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(36);
+    p.PrintKeyBool("performanceCounterQueryPools", static_cast<bool>(obj.performanceCounterQueryPools));
+    p.PrintKeyBool("performanceCounterMultipleQueryPools", static_cast<bool>(obj.performanceCounterMultipleQueryPools));
+}
+void DumpVkPhysicalDevicePerformanceQueryPropertiesKHR(Printer &p, std::string name,
+                                                       const VkPhysicalDevicePerformanceQueryPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(29);
+    p.PrintKeyBool("allowCommandBufferQueryCopies", static_cast<bool>(obj.allowCommandBufferQueryCopies));
+}
+void DumpVkPhysicalDevicePipelineBinaryFeaturesKHR(Printer &p, std::string name,
+                                                   const VkPhysicalDevicePipelineBinaryFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(16);
+    p.PrintKeyBool("pipelineBinaries", static_cast<bool>(obj.pipelineBinaries));
+}
+void DumpVkPhysicalDevicePipelineBinaryPropertiesKHR(Printer &p, std::string name,
+                                                     const VkPhysicalDevicePipelineBinaryPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(38);
+    p.PrintKeyBool("pipelineBinaryInternalCache", static_cast<bool>(obj.pipelineBinaryInternalCache));
+    p.PrintKeyBool("pipelineBinaryInternalCacheControl", static_cast<bool>(obj.pipelineBinaryInternalCacheControl));
+    p.PrintKeyBool("pipelineBinaryPrefersInternalCache", static_cast<bool>(obj.pipelineBinaryPrefersInternalCache));
+    p.PrintKeyBool("pipelineBinaryPrecompiledInternalCache", static_cast<bool>(obj.pipelineBinaryPrecompiledInternalCache));
+    p.PrintKeyBool("pipelineBinaryCompressedData", static_cast<bool>(obj.pipelineBinaryCompressedData));
+}
+void DumpVkPhysicalDevicePipelineCreationCacheControlFeatures(Printer &p, std::string name,
+                                                              const VkPhysicalDevicePipelineCreationCacheControlFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(28);
+    p.PrintKeyBool("pipelineCreationCacheControl", static_cast<bool>(obj.pipelineCreationCacheControl));
+}
+void DumpVkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
+    Printer &p, std::string name, const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(22);
+    p.PrintKeyBool("pipelineExecutableInfo", static_cast<bool>(obj.pipelineExecutableInfo));
+}
+void DumpVkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(Printer &p, std::string name,
+                                                                const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(27);
+    p.PrintKeyBool("pipelineLibraryGroupHandles", static_cast<bool>(obj.pipelineLibraryGroupHandles));
+}
+void DumpVkPhysicalDevicePipelinePropertiesFeaturesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDevicePipelinePropertiesFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(28);
+    p.PrintKeyBool("pipelinePropertiesIdentifier", static_cast<bool>(obj.pipelinePropertiesIdentifier));
+}
+void DumpVkPhysicalDevicePipelineProtectedAccessFeatures(Printer &p, std::string name,
+                                                         const VkPhysicalDevicePipelineProtectedAccessFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(23);
+    p.PrintKeyBool("pipelineProtectedAccess", static_cast<bool>(obj.pipelineProtectedAccess));
+}
+void DumpVkPhysicalDevicePipelineRobustnessFeatures(Printer &p, std::string name,
+                                                    const VkPhysicalDevicePipelineRobustnessFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(18);
+    p.PrintKeyBool("pipelineRobustness", static_cast<bool>(obj.pipelineRobustness));
+}
+void DumpVkPhysicalDevicePipelineRobustnessProperties(Printer &p, std::string name,
+                                                      const VkPhysicalDevicePipelineRobustnessProperties &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkPipelineRobustnessBufferBehavior(p, "defaultRobustnessStorageBuffers", obj.defaultRobustnessStorageBuffers);
+    DumpVkPipelineRobustnessBufferBehavior(p, "defaultRobustnessUniformBuffers", obj.defaultRobustnessUniformBuffers);
+    DumpVkPipelineRobustnessBufferBehavior(p, "defaultRobustnessVertexInputs", obj.defaultRobustnessVertexInputs);
+    DumpVkPipelineRobustnessImageBehavior(p, "defaultRobustnessImages", obj.defaultRobustnessImages);
+}
+void DumpVkPhysicalDevicePointClippingProperties(Printer &p, std::string name, const VkPhysicalDevicePointClippingProperties &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkPointClippingBehavior(p, "pointClippingBehavior", obj.pointClippingBehavior);
+}
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+void DumpVkPhysicalDevicePortabilitySubsetFeaturesKHR(Printer &p, std::string name,
+                                                      const VkPhysicalDevicePortabilitySubsetFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(38);
+    p.PrintKeyBool("constantAlphaColorBlendFactors", static_cast<bool>(obj.constantAlphaColorBlendFactors));
+    p.PrintKeyBool("events", static_cast<bool>(obj.events));
+    p.PrintKeyBool("imageViewFormatReinterpretation", static_cast<bool>(obj.imageViewFormatReinterpretation));
+    p.PrintKeyBool("imageViewFormatSwizzle", static_cast<bool>(obj.imageViewFormatSwizzle));
+    p.PrintKeyBool("imageView2DOn3DImage", static_cast<bool>(obj.imageView2DOn3DImage));
+    p.PrintKeyBool("multisampleArrayImage", static_cast<bool>(obj.multisampleArrayImage));
+    p.PrintKeyBool("mutableComparisonSamplers", static_cast<bool>(obj.mutableComparisonSamplers));
+    p.PrintKeyBool("pointPolygons", static_cast<bool>(obj.pointPolygons));
+    p.PrintKeyBool("samplerMipLodBias", static_cast<bool>(obj.samplerMipLodBias));
+    p.PrintKeyBool("separateStencilMaskRef", static_cast<bool>(obj.separateStencilMaskRef));
+    p.PrintKeyBool("shaderSampleRateInterpolationFunctions", static_cast<bool>(obj.shaderSampleRateInterpolationFunctions));
+    p.PrintKeyBool("tessellationIsolines", static_cast<bool>(obj.tessellationIsolines));
+    p.PrintKeyBool("tessellationPointMode", static_cast<bool>(obj.tessellationPointMode));
+    p.PrintKeyBool("triangleFans", static_cast<bool>(obj.triangleFans));
+    p.PrintKeyBool("vertexAttributeAccessBeyondStride", static_cast<bool>(obj.vertexAttributeAccessBeyondStride));
+}
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+void DumpVkPhysicalDevicePortabilitySubsetPropertiesKHR(Printer &p, std::string name,
+                                                        const VkPhysicalDevicePortabilitySubsetPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(36);
+    p.PrintKeyValue("minVertexInputBindingStrideAlignment", obj.minVertexInputBindingStrideAlignment);
+}
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+void DumpVkPhysicalDevicePresentId2FeaturesKHR(Printer &p, std::string name, const VkPhysicalDevicePresentId2FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(10);
+    p.PrintKeyBool("presentId2", static_cast<bool>(obj.presentId2));
+}
+void DumpVkPhysicalDevicePresentIdFeaturesKHR(Printer &p, std::string name, const VkPhysicalDevicePresentIdFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(9);
+    p.PrintKeyBool("presentId", static_cast<bool>(obj.presentId));
+}
+void DumpVkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR(Printer &p, std::string name,
+                                                               const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(26);
+    p.PrintKeyBool("presentModeFifoLatestReady", static_cast<bool>(obj.presentModeFifoLatestReady));
+}
+void DumpVkPhysicalDevicePresentTimingFeaturesEXT(Printer &p, std::string name,
+                                                  const VkPhysicalDevicePresentTimingFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(21);
+    p.PrintKeyBool("presentTiming", static_cast<bool>(obj.presentTiming));
+    p.PrintKeyBool("presentAtAbsoluteTime", static_cast<bool>(obj.presentAtAbsoluteTime));
+    p.PrintKeyBool("presentAtRelativeTime", static_cast<bool>(obj.presentAtRelativeTime));
+}
+void DumpVkPhysicalDevicePresentWait2FeaturesKHR(Printer &p, std::string name, const VkPhysicalDevicePresentWait2FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(12);
+    p.PrintKeyBool("presentWait2", static_cast<bool>(obj.presentWait2));
+}
+void DumpVkPhysicalDevicePresentWaitFeaturesKHR(Printer &p, std::string name, const VkPhysicalDevicePresentWaitFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(11);
+    p.PrintKeyBool("presentWait", static_cast<bool>(obj.presentWait));
+}
+void DumpVkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(33);
+    p.PrintKeyBool("primitiveTopologyListRestart", static_cast<bool>(obj.primitiveTopologyListRestart));
+    p.PrintKeyBool("primitiveTopologyPatchListRestart", static_cast<bool>(obj.primitiveTopologyPatchListRestart));
+}
+void DumpVkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(45);
+    p.PrintKeyBool("primitivesGeneratedQuery", static_cast<bool>(obj.primitivesGeneratedQuery));
+    p.PrintKeyBool("primitivesGeneratedQueryWithRasterizerDiscard",
+                   static_cast<bool>(obj.primitivesGeneratedQueryWithRasterizerDiscard));
+    p.PrintKeyBool("primitivesGeneratedQueryWithNonZeroStreams", static_cast<bool>(obj.primitivesGeneratedQueryWithNonZeroStreams));
+}
+void DumpVkPhysicalDevicePrivateDataFeatures(Printer &p, std::string name, const VkPhysicalDevicePrivateDataFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(11);
+    p.PrintKeyBool("privateData", static_cast<bool>(obj.privateData));
+}
+void DumpVkPhysicalDeviceProtectedMemoryFeatures(Printer &p, std::string name, const VkPhysicalDeviceProtectedMemoryFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(15);
+    p.PrintKeyBool("protectedMemory", static_cast<bool>(obj.protectedMemory));
+}
+void DumpVkPhysicalDeviceProtectedMemoryProperties(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceProtectedMemoryProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(16);
+    p.PrintKeyBool("protectedNoFault", static_cast<bool>(obj.protectedNoFault));
+}
+void DumpVkPhysicalDeviceProvokingVertexFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceProvokingVertexFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(41);
+    p.PrintKeyBool("provokingVertexLast", static_cast<bool>(obj.provokingVertexLast));
+    p.PrintKeyBool("transformFeedbackPreservesProvokingVertex", static_cast<bool>(obj.transformFeedbackPreservesProvokingVertex));
+}
+void DumpVkPhysicalDeviceProvokingVertexPropertiesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceProvokingVertexPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(52);
+    p.PrintKeyBool("provokingVertexModePerPipeline", static_cast<bool>(obj.provokingVertexModePerPipeline));
+    p.PrintKeyBool("transformFeedbackPreservesTriangleFanProvokingVertex",
+                   static_cast<bool>(obj.transformFeedbackPreservesTriangleFanProvokingVertex));
+}
+void DumpVkPhysicalDevicePushDescriptorProperties(Printer &p, std::string name,
+                                                  const VkPhysicalDevicePushDescriptorProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(18);
+    p.PrintKeyValue("maxPushDescriptors", obj.maxPushDescriptors);
+}
+void DumpVkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(33);
+    p.PrintKeyBool("formatRgba10x6WithoutYCbCrSampler", static_cast<bool>(obj.formatRgba10x6WithoutYCbCrSampler));
+}
+void DumpVkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(41);
+    p.PrintKeyBool("rasterizationOrderColorAttachmentAccess", static_cast<bool>(obj.rasterizationOrderColorAttachmentAccess));
+    p.PrintKeyBool("rasterizationOrderDepthAttachmentAccess", static_cast<bool>(obj.rasterizationOrderDepthAttachmentAccess));
+    p.PrintKeyBool("rasterizationOrderStencilAttachmentAccess", static_cast<bool>(obj.rasterizationOrderStencilAttachmentAccess));
+}
+void DumpVkPhysicalDeviceRayQueryFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceRayQueryFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(8);
+    p.PrintKeyBool("rayQuery", static_cast<bool>(obj.rayQuery));
+}
+void DumpVkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT(Printer &p, std::string name,
+                                                                const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(27);
+    p.PrintKeyBool("rayTracingInvocationReorder", static_cast<bool>(obj.rayTracingInvocationReorder));
+}
+void DumpVkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(32);
+    DumpVkRayTracingInvocationReorderModeEXT(p, "rayTracingInvocationReorderReorderingHint",
+                                             obj.rayTracingInvocationReorderReorderingHint);
+    p.PrintKeyValue("maxShaderBindingTableRecordIndex", obj.maxShaderBindingTableRecordIndex);
+}
+void DumpVkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(36);
+    p.PrintKeyBool("rayTracingMaintenance1", static_cast<bool>(obj.rayTracingMaintenance1));
+    p.PrintKeyBool("rayTracingPipelineTraceRaysIndirect2", static_cast<bool>(obj.rayTracingPipelineTraceRaysIndirect2));
+}
+void DumpVkPhysicalDeviceRayTracingPipelineFeaturesKHR(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceRayTracingPipelineFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(53);
+    p.PrintKeyBool("rayTracingPipeline", static_cast<bool>(obj.rayTracingPipeline));
+    p.PrintKeyBool("rayTracingPipelineShaderGroupHandleCaptureReplay",
+                   static_cast<bool>(obj.rayTracingPipelineShaderGroupHandleCaptureReplay));
+    p.PrintKeyBool("rayTracingPipelineShaderGroupHandleCaptureReplayMixed",
+                   static_cast<bool>(obj.rayTracingPipelineShaderGroupHandleCaptureReplayMixed));
+    p.PrintKeyBool("rayTracingPipelineTraceRaysIndirect", static_cast<bool>(obj.rayTracingPipelineTraceRaysIndirect));
+    p.PrintKeyBool("rayTraversalPrimitiveCulling", static_cast<bool>(obj.rayTraversalPrimitiveCulling));
+}
+void DumpVkPhysicalDeviceRayTracingPipelinePropertiesKHR(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceRayTracingPipelinePropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(34);
+    p.PrintKeyValue("shaderGroupHandleSize", obj.shaderGroupHandleSize);
+    p.PrintKeyValue("maxRayRecursionDepth", obj.maxRayRecursionDepth);
+    p.PrintKeyValue("maxShaderGroupStride", obj.maxShaderGroupStride);
+    p.PrintKeyValue("shaderGroupBaseAlignment", obj.shaderGroupBaseAlignment);
+    p.PrintKeyValue("shaderGroupHandleCaptureReplaySize", obj.shaderGroupHandleCaptureReplaySize);
+    p.PrintKeyValue("maxRayDispatchInvocationCount", obj.maxRayDispatchInvocationCount);
+    p.PrintKeyValue("shaderGroupHandleAlignment", obj.shaderGroupHandleAlignment);
+    p.PrintKeyValue("maxRayHitAttributeSize", obj.maxRayHitAttributeSize);
+}
+void DumpVkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(23);
+    p.PrintKeyBool("rayTracingPositionFetch", static_cast<bool>(obj.rayTracingPositionFetch));
+}
+void DumpVkPhysicalDeviceRobustness2FeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceRobustness2FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(19);
+    p.PrintKeyBool("robustBufferAccess2", static_cast<bool>(obj.robustBufferAccess2));
+    p.PrintKeyBool("robustImageAccess2", static_cast<bool>(obj.robustImageAccess2));
+    p.PrintKeyBool("nullDescriptor", static_cast<bool>(obj.nullDescriptor));
+}
+void DumpVkPhysicalDeviceRobustness2PropertiesKHR(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceRobustness2PropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(38);
+    p.PrintKeyValue("robustStorageBufferAccessSizeAlignment", to_hex_str(p, obj.robustStorageBufferAccessSizeAlignment));
+    p.PrintKeyValue("robustUniformBufferAccessSizeAlignment", to_hex_str(p, obj.robustUniformBufferAccessSizeAlignment));
+}
+void DumpVkPhysicalDeviceSampleLocationsPropertiesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceSampleLocationsPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(26);
+    DumpVkSampleCountFlags(p, "sampleLocationSampleCounts", obj.sampleLocationSampleCounts);
+    DumpVkExtent2D(p, "maxSampleLocationGridSize", obj.maxSampleLocationGridSize);
+    {
+        ArrayWrapper arr(p, "sampleLocationCoordinateRange", 2);
+        for (uint32_t i = 0; i < 2; i++) {
+            p.PrintElement(obj.sampleLocationCoordinateRange[i]);
+        }
+    }
+    p.PrintKeyValue("sampleLocationSubPixelBits", obj.sampleLocationSubPixelBits);
+    p.PrintKeyBool("variableSampleLocations", static_cast<bool>(obj.variableSampleLocations));
+}
+void DumpVkPhysicalDeviceSamplerFilterMinmaxProperties(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceSamplerFilterMinmaxProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(34);
+    p.PrintKeyBool("filterMinmaxSingleComponentFormats", static_cast<bool>(obj.filterMinmaxSingleComponentFormats));
+    p.PrintKeyBool("filterMinmaxImageComponentMapping", static_cast<bool>(obj.filterMinmaxImageComponentMapping));
+}
+void DumpVkPhysicalDeviceSamplerYcbcrConversionFeatures(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceSamplerYcbcrConversionFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(22);
+    p.PrintKeyBool("samplerYcbcrConversion", static_cast<bool>(obj.samplerYcbcrConversion));
+}
+void DumpVkPhysicalDeviceScalarBlockLayoutFeatures(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceScalarBlockLayoutFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyBool("scalarBlockLayout", static_cast<bool>(obj.scalarBlockLayout));
+}
+void DumpVkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(27);
+    p.PrintKeyBool("separateDepthStencilLayouts", static_cast<bool>(obj.separateDepthStencilLayouts));
+}
+void DumpVkPhysicalDeviceShader64BitIndexingFeaturesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceShader64BitIndexingFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(19);
+    p.PrintKeyBool("shader64BitIndexing", static_cast<bool>(obj.shader64BitIndexing));
+}
+void DumpVkPhysicalDeviceShaderAbortFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceShaderAbortFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(11);
+    p.PrintKeyBool("shaderAbort", static_cast<bool>(obj.shaderAbort));
+}
+void DumpVkPhysicalDeviceShaderAbortPropertiesKHR(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceShaderAbortPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(25);
+    p.PrintKeyValue("maxShaderAbortMessageSize", obj.maxShaderAbortMessageSize);
+}
+void DumpVkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(31);
+    p.PrintKeyBool("shaderBufferFloat16Atomics", static_cast<bool>(obj.shaderBufferFloat16Atomics));
+    p.PrintKeyBool("shaderBufferFloat16AtomicAdd", static_cast<bool>(obj.shaderBufferFloat16AtomicAdd));
+    p.PrintKeyBool("shaderBufferFloat16AtomicMinMax", static_cast<bool>(obj.shaderBufferFloat16AtomicMinMax));
+    p.PrintKeyBool("shaderBufferFloat32AtomicMinMax", static_cast<bool>(obj.shaderBufferFloat32AtomicMinMax));
+    p.PrintKeyBool("shaderBufferFloat64AtomicMinMax", static_cast<bool>(obj.shaderBufferFloat64AtomicMinMax));
+    p.PrintKeyBool("shaderSharedFloat16Atomics", static_cast<bool>(obj.shaderSharedFloat16Atomics));
+    p.PrintKeyBool("shaderSharedFloat16AtomicAdd", static_cast<bool>(obj.shaderSharedFloat16AtomicAdd));
+    p.PrintKeyBool("shaderSharedFloat16AtomicMinMax", static_cast<bool>(obj.shaderSharedFloat16AtomicMinMax));
+    p.PrintKeyBool("shaderSharedFloat32AtomicMinMax", static_cast<bool>(obj.shaderSharedFloat32AtomicMinMax));
+    p.PrintKeyBool("shaderSharedFloat64AtomicMinMax", static_cast<bool>(obj.shaderSharedFloat64AtomicMinMax));
+    p.PrintKeyBool("shaderImageFloat32AtomicMinMax", static_cast<bool>(obj.shaderImageFloat32AtomicMinMax));
+    p.PrintKeyBool("sparseImageFloat32AtomicMinMax", static_cast<bool>(obj.sparseImageFloat32AtomicMinMax));
+}
+void DumpVkPhysicalDeviceShaderAtomicFloatFeaturesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(28);
+    p.PrintKeyBool("shaderBufferFloat32Atomics", static_cast<bool>(obj.shaderBufferFloat32Atomics));
+    p.PrintKeyBool("shaderBufferFloat32AtomicAdd", static_cast<bool>(obj.shaderBufferFloat32AtomicAdd));
+    p.PrintKeyBool("shaderBufferFloat64Atomics", static_cast<bool>(obj.shaderBufferFloat64Atomics));
+    p.PrintKeyBool("shaderBufferFloat64AtomicAdd", static_cast<bool>(obj.shaderBufferFloat64AtomicAdd));
+    p.PrintKeyBool("shaderSharedFloat32Atomics", static_cast<bool>(obj.shaderSharedFloat32Atomics));
+    p.PrintKeyBool("shaderSharedFloat32AtomicAdd", static_cast<bool>(obj.shaderSharedFloat32AtomicAdd));
+    p.PrintKeyBool("shaderSharedFloat64Atomics", static_cast<bool>(obj.shaderSharedFloat64Atomics));
+    p.PrintKeyBool("shaderSharedFloat64AtomicAdd", static_cast<bool>(obj.shaderSharedFloat64AtomicAdd));
+    p.PrintKeyBool("shaderImageFloat32Atomics", static_cast<bool>(obj.shaderImageFloat32Atomics));
+    p.PrintKeyBool("shaderImageFloat32AtomicAdd", static_cast<bool>(obj.shaderImageFloat32AtomicAdd));
+    p.PrintKeyBool("sparseImageFloat32Atomics", static_cast<bool>(obj.sparseImageFloat32Atomics));
+    p.PrintKeyBool("sparseImageFloat32AtomicAdd", static_cast<bool>(obj.sparseImageFloat32AtomicAdd));
+}
+void DumpVkPhysicalDeviceShaderAtomicInt64Features(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceShaderAtomicInt64Features &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(24);
+    p.PrintKeyBool("shaderBufferInt64Atomics", static_cast<bool>(obj.shaderBufferInt64Atomics));
+    p.PrintKeyBool("shaderSharedInt64Atomics", static_cast<bool>(obj.shaderSharedInt64Atomics));
+}
+void DumpVkPhysicalDeviceShaderBfloat16FeaturesKHR(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceShaderBfloat16FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(31);
+    p.PrintKeyBool("shaderBFloat16Type", static_cast<bool>(obj.shaderBFloat16Type));
+    p.PrintKeyBool("shaderBFloat16DotProduct", static_cast<bool>(obj.shaderBFloat16DotProduct));
+    p.PrintKeyBool("shaderBFloat16CooperativeMatrix", static_cast<bool>(obj.shaderBFloat16CooperativeMatrix));
+}
+void DumpVkPhysicalDeviceShaderClockFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceShaderClockFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(19);
+    p.PrintKeyBool("shaderSubgroupClock", static_cast<bool>(obj.shaderSubgroupClock));
+    p.PrintKeyBool("shaderDeviceClock", static_cast<bool>(obj.shaderDeviceClock));
+}
+void DumpVkPhysicalDeviceShaderConstantDataFeaturesKHR(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceShaderConstantDataFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(18);
+    p.PrintKeyBool("shaderConstantData", static_cast<bool>(obj.shaderConstantData));
+}
+void DumpVkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(Printer &p, std::string name,
+                                                                const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(30);
+    p.PrintKeyBool("shaderDemoteToHelperInvocation", static_cast<bool>(obj.shaderDemoteToHelperInvocation));
+}
+void DumpVkPhysicalDeviceShaderDrawParametersFeatures(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceShaderDrawParametersFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(20);
+    p.PrintKeyBool("shaderDrawParameters", static_cast<bool>(obj.shaderDrawParameters));
+}
+void DumpVkPhysicalDeviceShaderExpectAssumeFeatures(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceShaderExpectAssumeFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(18);
+    p.PrintKeyBool("shaderExpectAssume", static_cast<bool>(obj.shaderExpectAssume));
+}
+void DumpVkPhysicalDeviceShaderFloat16Int8Features(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceShaderFloat16Int8Features &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(13);
+    p.PrintKeyBool("shaderFloat16", static_cast<bool>(obj.shaderFloat16));
+    p.PrintKeyBool("shaderInt8", static_cast<bool>(obj.shaderInt8));
+}
+void DumpVkPhysicalDeviceShaderFloat8FeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceShaderFloat8FeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(29);
+    p.PrintKeyBool("shaderFloat8", static_cast<bool>(obj.shaderFloat8));
+    p.PrintKeyBool("shaderFloat8CooperativeMatrix", static_cast<bool>(obj.shaderFloat8CooperativeMatrix));
+}
+void DumpVkPhysicalDeviceShaderFloatControls2Features(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceShaderFloatControls2Features &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(20);
+    p.PrintKeyBool("shaderFloatControls2", static_cast<bool>(obj.shaderFloatControls2));
+}
+void DumpVkPhysicalDeviceShaderFmaFeaturesKHR(Printer &p, std::string name, const VkPhysicalDeviceShaderFmaFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(16);
+    p.PrintKeyBool("shaderFmaFloat16", static_cast<bool>(obj.shaderFmaFloat16));
+    p.PrintKeyBool("shaderFmaFloat32", static_cast<bool>(obj.shaderFmaFloat32));
+    p.PrintKeyBool("shaderFmaFloat64", static_cast<bool>(obj.shaderFmaFloat64));
+}
+void DumpVkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(23);
+    p.PrintKeyBool("shaderImageInt64Atomics", static_cast<bool>(obj.shaderImageInt64Atomics));
+    p.PrintKeyBool("sparseImageInt64Atomics", static_cast<bool>(obj.sparseImageInt64Atomics));
+}
+void DumpVkPhysicalDeviceShaderIntegerDotProductFeatures(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceShaderIntegerDotProductFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(23);
+    p.PrintKeyBool("shaderIntegerDotProduct", static_cast<bool>(obj.shaderIntegerDotProduct));
+}
+void DumpVkPhysicalDeviceShaderIntegerDotProductProperties(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceShaderIntegerDotProductProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(77);
+    p.PrintKeyBool("integerDotProduct8BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct8BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProduct8BitSignedAccelerated", static_cast<bool>(obj.integerDotProduct8BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProduct8BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProduct8BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProduct4x8BitPackedUnsignedAccelerated",
+                   static_cast<bool>(obj.integerDotProduct4x8BitPackedUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProduct4x8BitPackedSignedAccelerated",
+                   static_cast<bool>(obj.integerDotProduct4x8BitPackedSignedAccelerated));
+    p.PrintKeyBool("integerDotProduct4x8BitPackedMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProduct4x8BitPackedMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProduct16BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct16BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProduct16BitSignedAccelerated", static_cast<bool>(obj.integerDotProduct16BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProduct16BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProduct16BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProduct32BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct32BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProduct32BitSignedAccelerated", static_cast<bool>(obj.integerDotProduct32BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProduct32BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProduct32BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProduct64BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct64BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProduct64BitSignedAccelerated", static_cast<bool>(obj.integerDotProduct64BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProduct64BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProduct64BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating8BitUnsignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating8BitSignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating8BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating16BitUnsignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating16BitSignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating16BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating32BitUnsignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating32BitSignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating32BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating64BitUnsignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating64BitSignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating64BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated));
+}
+void DumpVkPhysicalDeviceShaderLongVectorFeaturesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceShaderLongVectorFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(10);
+    p.PrintKeyBool("longVector", static_cast<bool>(obj.longVector));
+}
+void DumpVkPhysicalDeviceShaderLongVectorPropertiesEXT(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceShaderLongVectorPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(19);
+    p.PrintKeyValue("maxVectorComponents", obj.maxVectorComponents);
+}
+void DumpVkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(26);
+    p.PrintKeyBool("shaderMaximalReconvergence", static_cast<bool>(obj.shaderMaximalReconvergence));
+}
+void DumpVkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(22);
+    p.PrintKeyBool("shaderModuleIdentifier", static_cast<bool>(obj.shaderModuleIdentifier));
+}
+void DumpVkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(35);
+    p.PrintKeyValue("shaderModuleIdentifierAlgorithmUUID", obj.shaderModuleIdentifierAlgorithmUUID);
+}
+void DumpVkPhysicalDeviceShaderObjectFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceShaderObjectFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(12);
+    p.PrintKeyBool("shaderObject", static_cast<bool>(obj.shaderObject));
+}
+void DumpVkPhysicalDeviceShaderObjectPropertiesEXT(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceShaderObjectPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(19);
+    p.PrintKeyValue("shaderBinaryUUID", obj.shaderBinaryUUID);
+    p.PrintKeyValue("shaderBinaryVersion", obj.shaderBinaryVersion);
+}
+void DumpVkPhysicalDeviceShaderQuadControlFeaturesKHR(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceShaderQuadControlFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyBool("shaderQuadControl", static_cast<bool>(obj.shaderQuadControl));
+}
+void DumpVkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(
+    Printer &p, std::string name, const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(32);
+    p.PrintKeyBool("shaderRelaxedExtendedInstruction", static_cast<bool>(obj.shaderRelaxedExtendedInstruction));
+}
+void DumpVkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(26);
+    p.PrintKeyBool("shaderReplicatedComposites", static_cast<bool>(obj.shaderReplicatedComposites));
+}
+void DumpVkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(27);
+    p.PrintKeyBool("shaderSubgroupExtendedTypes", static_cast<bool>(obj.shaderSubgroupExtendedTypes));
+}
+void DumpVkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT(Printer &p, std::string name,
+                                                              const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(25);
+    p.PrintKeyBool("shaderSubgroupPartitioned", static_cast<bool>(obj.shaderSubgroupPartitioned));
+}
+void DumpVkPhysicalDeviceShaderSubgroupRotateFeatures(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceShaderSubgroupRotateFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(29);
+    p.PrintKeyBool("shaderSubgroupRotate", static_cast<bool>(obj.shaderSubgroupRotate));
+    p.PrintKeyBool("shaderSubgroupRotateClustered", static_cast<bool>(obj.shaderSubgroupRotateClustered));
+}
+void DumpVkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
+    Printer &p, std::string name, const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(32);
+    p.PrintKeyBool("shaderSubgroupUniformControlFlow", static_cast<bool>(obj.shaderSubgroupUniformControlFlow));
+}
+void DumpVkPhysicalDeviceShaderTerminateInvocationFeatures(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceShaderTerminateInvocationFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(25);
+    p.PrintKeyBool("shaderTerminateInvocation", static_cast<bool>(obj.shaderTerminateInvocation));
+}
+void DumpVkPhysicalDeviceShaderTileImageFeaturesEXT(Printer &p, std::string name,
+                                                    const VkPhysicalDeviceShaderTileImageFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(32);
+    p.PrintKeyBool("shaderTileImageColorReadAccess", static_cast<bool>(obj.shaderTileImageColorReadAccess));
+    p.PrintKeyBool("shaderTileImageDepthReadAccess", static_cast<bool>(obj.shaderTileImageDepthReadAccess));
+    p.PrintKeyBool("shaderTileImageStencilReadAccess", static_cast<bool>(obj.shaderTileImageStencilReadAccess));
+}
+void DumpVkPhysicalDeviceShaderTileImagePropertiesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceShaderTileImagePropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(48);
+    p.PrintKeyBool("shaderTileImageCoherentReadAccelerated", static_cast<bool>(obj.shaderTileImageCoherentReadAccelerated));
+    p.PrintKeyBool("shaderTileImageReadSampleFromPixelRateInvocation",
+                   static_cast<bool>(obj.shaderTileImageReadSampleFromPixelRateInvocation));
+    p.PrintKeyBool("shaderTileImageReadFromHelperInvocation", static_cast<bool>(obj.shaderTileImageReadFromHelperInvocation));
+}
+void DumpVkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT(
+    Printer &p, std::string name, const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(31);
+    p.PrintKeyBool("shaderUniformBufferUnsizedArray", static_cast<bool>(obj.shaderUniformBufferUnsizedArray));
+}
+void DumpVkPhysicalDeviceShaderUntypedPointersFeaturesKHR(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(21);
+    p.PrintKeyBool("shaderUntypedPointers", static_cast<bool>(obj.shaderUntypedPointers));
+}
+void DumpVkPhysicalDeviceSparseProperties(Printer &p, std::string name, const VkPhysicalDeviceSparseProperties &obj) {
+    if (p.Type() == OutputType::json)
+        p.ObjectStart("sparseProperties");
+    else
+        p.SetSubHeader().ObjectStart(name);
+    p.SetMinKeyWidth(40);
+    p.PrintKeyBool("residencyStandard2DBlockShape", static_cast<bool>(obj.residencyStandard2DBlockShape));
+    p.PrintKeyBool("residencyStandard2DMultisampleBlockShape", static_cast<bool>(obj.residencyStandard2DMultisampleBlockShape));
+    p.PrintKeyBool("residencyStandard3DBlockShape", static_cast<bool>(obj.residencyStandard3DBlockShape));
+    p.PrintKeyBool("residencyAlignedMipSize", static_cast<bool>(obj.residencyAlignedMipSize));
+    p.PrintKeyBool("residencyNonResidentStrict", static_cast<bool>(obj.residencyNonResidentStrict));
+    p.ObjectEnd();
+}
+void DumpVkPhysicalDeviceSubgroupProperties(Printer &p, std::string name, const VkPhysicalDeviceSubgroupProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(25);
+    p.PrintKeyValue("subgroupSize", obj.subgroupSize);
+    DumpVkShaderStageFlags(p, "supportedStages", obj.supportedStages);
+    DumpVkSubgroupFeatureFlags(p, "supportedOperations", obj.supportedOperations);
+    p.PrintKeyBool("quadOperationsInAllStages", static_cast<bool>(obj.quadOperationsInAllStages));
+}
+void DumpVkPhysicalDeviceSubgroupSizeControlFeatures(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceSubgroupSizeControlFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(20);
+    p.PrintKeyBool("subgroupSizeControl", static_cast<bool>(obj.subgroupSizeControl));
+    p.PrintKeyBool("computeFullSubgroups", static_cast<bool>(obj.computeFullSubgroups));
+}
+void DumpVkPhysicalDeviceSubgroupSizeControlProperties(Printer &p, std::string name,
+                                                       const VkPhysicalDeviceSubgroupSizeControlProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(28);
+    p.PrintKeyValue("minSubgroupSize", obj.minSubgroupSize);
+    p.PrintKeyValue("maxSubgroupSize", obj.maxSubgroupSize);
+    p.PrintKeyValue("maxComputeWorkgroupSubgroups", obj.maxComputeWorkgroupSubgroups);
+    DumpVkShaderStageFlags(p, "requiredSubgroupSizeStages", obj.requiredSubgroupSizeStages);
+}
+void DumpVkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(20);
+    p.PrintKeyBool("subpassMergeFeedback", static_cast<bool>(obj.subpassMergeFeedback));
+}
+void DumpVkPhysicalDeviceSwapchainMaintenance1FeaturesKHR(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(21);
+    p.PrintKeyBool("swapchainMaintenance1", static_cast<bool>(obj.swapchainMaintenance1));
+}
+void DumpVkPhysicalDeviceSynchronization2Features(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceSynchronization2Features &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(16);
+    p.PrintKeyBool("synchronization2", static_cast<bool>(obj.synchronization2));
+}
+void DumpVkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(Printer &p, std::string name,
+                                                         const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(20);
+    p.PrintKeyBool("texelBufferAlignment", static_cast<bool>(obj.texelBufferAlignment));
+}
+void DumpVkPhysicalDeviceTexelBufferAlignmentProperties(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceTexelBufferAlignmentProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(44);
+    p.PrintKeyValue("storageTexelBufferOffsetAlignmentBytes", to_hex_str(p, obj.storageTexelBufferOffsetAlignmentBytes));
+    p.PrintKeyBool("storageTexelBufferOffsetSingleTexelAlignment",
+                   static_cast<bool>(obj.storageTexelBufferOffsetSingleTexelAlignment));
+    p.PrintKeyValue("uniformTexelBufferOffsetAlignmentBytes", to_hex_str(p, obj.uniformTexelBufferOffsetAlignmentBytes));
+    p.PrintKeyBool("uniformTexelBufferOffsetSingleTexelAlignment",
+                   static_cast<bool>(obj.uniformTexelBufferOffsetSingleTexelAlignment));
+}
+void DumpVkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(25);
+    p.PrintKeyBool("textureCompressionASTC_3D", static_cast<bool>(obj.textureCompressionASTC_3D));
+}
+void DumpVkPhysicalDeviceTextureCompressionASTCHDRFeatures(Printer &p, std::string name,
+                                                           const VkPhysicalDeviceTextureCompressionASTCHDRFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(26);
+    p.PrintKeyBool("textureCompressionASTC_HDR", static_cast<bool>(obj.textureCompressionASTC_HDR));
+}
+void DumpVkPhysicalDeviceTimelineSemaphoreFeatures(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceTimelineSemaphoreFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyBool("timelineSemaphore", static_cast<bool>(obj.timelineSemaphore));
+}
+void DumpVkPhysicalDeviceTimelineSemaphoreProperties(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceTimelineSemaphoreProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(35);
+    p.PrintKeyValue("maxTimelineSemaphoreValueDifference", obj.maxTimelineSemaphoreValueDifference);
+}
+void DumpVkPhysicalDeviceToolProperties(Printer &p, std::string name, const VkPhysicalDeviceToolProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(11);
+    p.PrintKeyString("name", obj.name);
+    p.PrintKeyString("version", obj.version);
+    DumpVkToolPurposeFlags(p, "purposes", obj.purposes);
+    p.PrintKeyString("description", obj.description);
+    p.PrintKeyString("layer", obj.layer);
+}
+void DumpVkPhysicalDeviceTransformFeedbackFeaturesEXT(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceTransformFeedbackFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyBool("transformFeedback", static_cast<bool>(obj.transformFeedback));
+    p.PrintKeyBool("geometryStreams", static_cast<bool>(obj.geometryStreams));
+}
+void DumpVkPhysicalDeviceTransformFeedbackPropertiesEXT(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceTransformFeedbackPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(42);
+    p.PrintKeyValue("maxTransformFeedbackStreams", obj.maxTransformFeedbackStreams);
+    p.PrintKeyValue("maxTransformFeedbackBuffers", obj.maxTransformFeedbackBuffers);
+    p.PrintKeyValue("maxTransformFeedbackBufferSize", to_hex_str(p, obj.maxTransformFeedbackBufferSize));
+    p.PrintKeyValue("maxTransformFeedbackStreamDataSize", obj.maxTransformFeedbackStreamDataSize);
+    p.PrintKeyValue("maxTransformFeedbackBufferDataSize", obj.maxTransformFeedbackBufferDataSize);
+    p.PrintKeyValue("maxTransformFeedbackBufferDataStride", obj.maxTransformFeedbackBufferDataStride);
+    p.PrintKeyBool("transformFeedbackQueries", static_cast<bool>(obj.transformFeedbackQueries));
+    p.PrintKeyBool("transformFeedbackStreamsLinesTriangles", static_cast<bool>(obj.transformFeedbackStreamsLinesTriangles));
+    p.PrintKeyBool("transformFeedbackRasterizationStreamSelect", static_cast<bool>(obj.transformFeedbackRasterizationStreamSelect));
+    p.PrintKeyBool("transformFeedbackDraw", static_cast<bool>(obj.transformFeedbackDraw));
+}
+void DumpVkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(24);
+    p.PrintKeyBool("unifiedImageLayouts", static_cast<bool>(obj.unifiedImageLayouts));
+    p.PrintKeyBool("unifiedImageLayoutsVideo", static_cast<bool>(obj.unifiedImageLayoutsVideo));
+}
+void DumpVkPhysicalDeviceUniformBufferStandardLayoutFeatures(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(27);
+    p.PrintKeyBool("uniformBufferStandardLayout", static_cast<bool>(obj.uniformBufferStandardLayout));
+}
+void DumpVkPhysicalDeviceVariablePointersFeatures(Printer &p, std::string name,
+                                                  const VkPhysicalDeviceVariablePointersFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(29);
+    p.PrintKeyBool("variablePointersStorageBuffer", static_cast<bool>(obj.variablePointersStorageBuffer));
+    p.PrintKeyBool("variablePointers", static_cast<bool>(obj.variablePointers));
+}
+void DumpVkPhysicalDeviceVertexAttributeDivisorFeatures(Printer &p, std::string name,
+                                                        const VkPhysicalDeviceVertexAttributeDivisorFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(38);
+    p.PrintKeyBool("vertexAttributeInstanceRateDivisor", static_cast<bool>(obj.vertexAttributeInstanceRateDivisor));
+    p.PrintKeyBool("vertexAttributeInstanceRateZeroDivisor", static_cast<bool>(obj.vertexAttributeInstanceRateZeroDivisor));
+}
+void DumpVkPhysicalDeviceVertexAttributeDivisorProperties(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceVertexAttributeDivisorProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(28);
+    p.PrintKeyValue("maxVertexAttribDivisor", obj.maxVertexAttribDivisor);
+    p.PrintKeyBool("supportsNonZeroFirstInstance", static_cast<bool>(obj.supportsNonZeroFirstInstance));
+}
+void DumpVkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(Printer &p, std::string name,
+                                                             const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(22);
+    p.PrintKeyValue("maxVertexAttribDivisor", obj.maxVertexAttribDivisor);
+}
+void DumpVkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(Printer &p, std::string name,
+                                                              const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(25);
+    p.PrintKeyBool("vertexAttributeRobustness", static_cast<bool>(obj.vertexAttributeRobustness));
+}
+void DumpVkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(23);
+    p.PrintKeyBool("vertexInputDynamicState", static_cast<bool>(obj.vertexInputDynamicState));
+}
+void DumpVkPhysicalDeviceVideoDecodeVP9FeaturesKHR(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(14);
+    p.PrintKeyBool("videoDecodeVP9", static_cast<bool>(obj.videoDecodeVP9));
+}
+void DumpVkPhysicalDeviceVideoEncodeAV1FeaturesKHR(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(14);
+    p.PrintKeyBool("videoEncodeAV1", static_cast<bool>(obj.videoEncodeAV1));
+}
+void DumpVkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR(Printer &p, std::string name,
+                                                            const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(23);
+    p.PrintKeyBool("videoEncodeIntraRefresh", static_cast<bool>(obj.videoEncodeIntraRefresh));
+}
+void DumpVkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(26);
+    p.PrintKeyBool("videoEncodeQuantizationMap", static_cast<bool>(obj.videoEncodeQuantizationMap));
+}
+void DumpVkPhysicalDeviceVideoMaintenance1FeaturesKHR(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceVideoMaintenance1FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyBool("videoMaintenance1", static_cast<bool>(obj.videoMaintenance1));
+}
+void DumpVkPhysicalDeviceVideoMaintenance2FeaturesKHR(Printer &p, std::string name,
+                                                      const VkPhysicalDeviceVideoMaintenance2FeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyBool("videoMaintenance2", static_cast<bool>(obj.videoMaintenance2));
+}
+void DumpVkPhysicalDeviceVulkan11Features(Printer &p, std::string name, const VkPhysicalDeviceVulkan11Features &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(34);
+    p.PrintKeyBool("storageBuffer16BitAccess", static_cast<bool>(obj.storageBuffer16BitAccess));
+    p.PrintKeyBool("uniformAndStorageBuffer16BitAccess", static_cast<bool>(obj.uniformAndStorageBuffer16BitAccess));
+    p.PrintKeyBool("storagePushConstant16", static_cast<bool>(obj.storagePushConstant16));
+    p.PrintKeyBool("storageInputOutput16", static_cast<bool>(obj.storageInputOutput16));
+    p.PrintKeyBool("multiview", static_cast<bool>(obj.multiview));
+    p.PrintKeyBool("multiviewGeometryShader", static_cast<bool>(obj.multiviewGeometryShader));
+    p.PrintKeyBool("multiviewTessellationShader", static_cast<bool>(obj.multiviewTessellationShader));
+    p.PrintKeyBool("variablePointersStorageBuffer", static_cast<bool>(obj.variablePointersStorageBuffer));
+    p.PrintKeyBool("variablePointers", static_cast<bool>(obj.variablePointers));
+    p.PrintKeyBool("protectedMemory", static_cast<bool>(obj.protectedMemory));
+    p.PrintKeyBool("samplerYcbcrConversion", static_cast<bool>(obj.samplerYcbcrConversion));
+    p.PrintKeyBool("shaderDrawParameters", static_cast<bool>(obj.shaderDrawParameters));
+}
+void DumpVkPhysicalDeviceVulkan11Properties(Printer &p, std::string name, const VkPhysicalDeviceVulkan11Properties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(33);
+    p.PrintKeyValue("deviceUUID", obj.deviceUUID);
+    p.PrintKeyValue("driverUUID", obj.driverUUID);
+    if (obj.deviceLUIDValid) {  // special case
+        p.PrintKeyValue("deviceLUID", obj.deviceLUID);
+    }
+    p.PrintKeyValue("deviceNodeMask", obj.deviceNodeMask);
+    p.PrintKeyBool("deviceLUIDValid", static_cast<bool>(obj.deviceLUIDValid));
+    p.PrintKeyValue("subgroupSize", obj.subgroupSize);
+    DumpVkShaderStageFlags(p, "subgroupSupportedStages", obj.subgroupSupportedStages);
+    DumpVkSubgroupFeatureFlags(p, "subgroupSupportedOperations", obj.subgroupSupportedOperations);
+    p.PrintKeyBool("subgroupQuadOperationsInAllStages", static_cast<bool>(obj.subgroupQuadOperationsInAllStages));
+    DumpVkPointClippingBehavior(p, "pointClippingBehavior", obj.pointClippingBehavior);
+    p.PrintKeyValue("maxMultiviewViewCount", obj.maxMultiviewViewCount);
+    p.PrintKeyValue("maxMultiviewInstanceIndex", obj.maxMultiviewInstanceIndex);
+    p.PrintKeyBool("protectedNoFault", static_cast<bool>(obj.protectedNoFault));
+    p.PrintKeyValue("maxPerSetDescriptors", obj.maxPerSetDescriptors);
+    p.PrintKeyValue("maxMemoryAllocationSize", to_hex_str(p, obj.maxMemoryAllocationSize));
+}
+void DumpVkPhysicalDeviceVulkan12Features(Printer &p, std::string name, const VkPhysicalDeviceVulkan12Features &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(50);
+    p.PrintKeyBool("samplerMirrorClampToEdge", static_cast<bool>(obj.samplerMirrorClampToEdge));
+    p.PrintKeyBool("drawIndirectCount", static_cast<bool>(obj.drawIndirectCount));
+    p.PrintKeyBool("storageBuffer8BitAccess", static_cast<bool>(obj.storageBuffer8BitAccess));
+    p.PrintKeyBool("uniformAndStorageBuffer8BitAccess", static_cast<bool>(obj.uniformAndStorageBuffer8BitAccess));
+    p.PrintKeyBool("storagePushConstant8", static_cast<bool>(obj.storagePushConstant8));
+    p.PrintKeyBool("shaderBufferInt64Atomics", static_cast<bool>(obj.shaderBufferInt64Atomics));
+    p.PrintKeyBool("shaderSharedInt64Atomics", static_cast<bool>(obj.shaderSharedInt64Atomics));
+    p.PrintKeyBool("shaderFloat16", static_cast<bool>(obj.shaderFloat16));
+    p.PrintKeyBool("shaderInt8", static_cast<bool>(obj.shaderInt8));
+    p.PrintKeyBool("descriptorIndexing", static_cast<bool>(obj.descriptorIndexing));
+    p.PrintKeyBool("shaderInputAttachmentArrayDynamicIndexing", static_cast<bool>(obj.shaderInputAttachmentArrayDynamicIndexing));
+    p.PrintKeyBool("shaderUniformTexelBufferArrayDynamicIndexing",
+                   static_cast<bool>(obj.shaderUniformTexelBufferArrayDynamicIndexing));
+    p.PrintKeyBool("shaderStorageTexelBufferArrayDynamicIndexing",
+                   static_cast<bool>(obj.shaderStorageTexelBufferArrayDynamicIndexing));
+    p.PrintKeyBool("shaderUniformBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderUniformBufferArrayNonUniformIndexing));
+    p.PrintKeyBool("shaderSampledImageArrayNonUniformIndexing", static_cast<bool>(obj.shaderSampledImageArrayNonUniformIndexing));
+    p.PrintKeyBool("shaderStorageBufferArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageBufferArrayNonUniformIndexing));
+    p.PrintKeyBool("shaderStorageImageArrayNonUniformIndexing", static_cast<bool>(obj.shaderStorageImageArrayNonUniformIndexing));
+    p.PrintKeyBool("shaderInputAttachmentArrayNonUniformIndexing",
+                   static_cast<bool>(obj.shaderInputAttachmentArrayNonUniformIndexing));
+    p.PrintKeyBool("shaderUniformTexelBufferArrayNonUniformIndexing",
+                   static_cast<bool>(obj.shaderUniformTexelBufferArrayNonUniformIndexing));
+    p.PrintKeyBool("shaderStorageTexelBufferArrayNonUniformIndexing",
+                   static_cast<bool>(obj.shaderStorageTexelBufferArrayNonUniformIndexing));
+    p.PrintKeyBool("descriptorBindingUniformBufferUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingUniformBufferUpdateAfterBind));
+    p.PrintKeyBool("descriptorBindingSampledImageUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingSampledImageUpdateAfterBind));
+    p.PrintKeyBool("descriptorBindingStorageImageUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingStorageImageUpdateAfterBind));
+    p.PrintKeyBool("descriptorBindingStorageBufferUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingStorageBufferUpdateAfterBind));
+    p.PrintKeyBool("descriptorBindingUniformTexelBufferUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingUniformTexelBufferUpdateAfterBind));
+    p.PrintKeyBool("descriptorBindingStorageTexelBufferUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingStorageTexelBufferUpdateAfterBind));
+    p.PrintKeyBool("descriptorBindingUpdateUnusedWhilePending", static_cast<bool>(obj.descriptorBindingUpdateUnusedWhilePending));
+    p.PrintKeyBool("descriptorBindingPartiallyBound", static_cast<bool>(obj.descriptorBindingPartiallyBound));
+    p.PrintKeyBool("descriptorBindingVariableDescriptorCount", static_cast<bool>(obj.descriptorBindingVariableDescriptorCount));
+    p.PrintKeyBool("runtimeDescriptorArray", static_cast<bool>(obj.runtimeDescriptorArray));
+    p.PrintKeyBool("samplerFilterMinmax", static_cast<bool>(obj.samplerFilterMinmax));
+    p.PrintKeyBool("scalarBlockLayout", static_cast<bool>(obj.scalarBlockLayout));
+    p.PrintKeyBool("imagelessFramebuffer", static_cast<bool>(obj.imagelessFramebuffer));
+    p.PrintKeyBool("uniformBufferStandardLayout", static_cast<bool>(obj.uniformBufferStandardLayout));
+    p.PrintKeyBool("shaderSubgroupExtendedTypes", static_cast<bool>(obj.shaderSubgroupExtendedTypes));
+    p.PrintKeyBool("separateDepthStencilLayouts", static_cast<bool>(obj.separateDepthStencilLayouts));
+    p.PrintKeyBool("hostQueryReset", static_cast<bool>(obj.hostQueryReset));
+    p.PrintKeyBool("timelineSemaphore", static_cast<bool>(obj.timelineSemaphore));
+    p.PrintKeyBool("bufferDeviceAddress", static_cast<bool>(obj.bufferDeviceAddress));
+    p.PrintKeyBool("bufferDeviceAddressCaptureReplay", static_cast<bool>(obj.bufferDeviceAddressCaptureReplay));
+    p.PrintKeyBool("bufferDeviceAddressMultiDevice", static_cast<bool>(obj.bufferDeviceAddressMultiDevice));
+    p.PrintKeyBool("vulkanMemoryModel", static_cast<bool>(obj.vulkanMemoryModel));
+    p.PrintKeyBool("vulkanMemoryModelDeviceScope", static_cast<bool>(obj.vulkanMemoryModelDeviceScope));
+    p.PrintKeyBool("vulkanMemoryModelAvailabilityVisibilityChains",
+                   static_cast<bool>(obj.vulkanMemoryModelAvailabilityVisibilityChains));
+    p.PrintKeyBool("shaderOutputViewportIndex", static_cast<bool>(obj.shaderOutputViewportIndex));
+    p.PrintKeyBool("shaderOutputLayer", static_cast<bool>(obj.shaderOutputLayer));
+    p.PrintKeyBool("subgroupBroadcastDynamicId", static_cast<bool>(obj.subgroupBroadcastDynamicId));
+}
+void DumpVkPhysicalDeviceVulkan12Properties(Printer &p, std::string name, const VkPhysicalDeviceVulkan12Properties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(52);
+    DumpVkDriverId(p, "driverID", obj.driverID);
+    p.PrintKeyString("driverName", obj.driverName);
+    p.PrintKeyString("driverInfo", obj.driverInfo);
+    DumpVkConformanceVersion(p, "conformanceVersion", obj.conformanceVersion);
+    DumpVkShaderFloatControlsIndependence(p, "denormBehaviorIndependence", obj.denormBehaviorIndependence);
+    DumpVkShaderFloatControlsIndependence(p, "roundingModeIndependence", obj.roundingModeIndependence);
+    p.PrintKeyBool("shaderSignedZeroInfNanPreserveFloat16", static_cast<bool>(obj.shaderSignedZeroInfNanPreserveFloat16));
+    p.PrintKeyBool("shaderSignedZeroInfNanPreserveFloat32", static_cast<bool>(obj.shaderSignedZeroInfNanPreserveFloat32));
+    p.PrintKeyBool("shaderSignedZeroInfNanPreserveFloat64", static_cast<bool>(obj.shaderSignedZeroInfNanPreserveFloat64));
+    p.PrintKeyBool("shaderDenormPreserveFloat16", static_cast<bool>(obj.shaderDenormPreserveFloat16));
+    p.PrintKeyBool("shaderDenormPreserveFloat32", static_cast<bool>(obj.shaderDenormPreserveFloat32));
+    p.PrintKeyBool("shaderDenormPreserveFloat64", static_cast<bool>(obj.shaderDenormPreserveFloat64));
+    p.PrintKeyBool("shaderDenormFlushToZeroFloat16", static_cast<bool>(obj.shaderDenormFlushToZeroFloat16));
+    p.PrintKeyBool("shaderDenormFlushToZeroFloat32", static_cast<bool>(obj.shaderDenormFlushToZeroFloat32));
+    p.PrintKeyBool("shaderDenormFlushToZeroFloat64", static_cast<bool>(obj.shaderDenormFlushToZeroFloat64));
+    p.PrintKeyBool("shaderRoundingModeRTEFloat16", static_cast<bool>(obj.shaderRoundingModeRTEFloat16));
+    p.PrintKeyBool("shaderRoundingModeRTEFloat32", static_cast<bool>(obj.shaderRoundingModeRTEFloat32));
+    p.PrintKeyBool("shaderRoundingModeRTEFloat64", static_cast<bool>(obj.shaderRoundingModeRTEFloat64));
+    p.PrintKeyBool("shaderRoundingModeRTZFloat16", static_cast<bool>(obj.shaderRoundingModeRTZFloat16));
+    p.PrintKeyBool("shaderRoundingModeRTZFloat32", static_cast<bool>(obj.shaderRoundingModeRTZFloat32));
+    p.PrintKeyBool("shaderRoundingModeRTZFloat64", static_cast<bool>(obj.shaderRoundingModeRTZFloat64));
+    p.PrintKeyValue("maxUpdateAfterBindDescriptorsInAllPools", obj.maxUpdateAfterBindDescriptorsInAllPools);
+    p.PrintKeyBool("shaderUniformBufferArrayNonUniformIndexingNative",
+                   static_cast<bool>(obj.shaderUniformBufferArrayNonUniformIndexingNative));
+    p.PrintKeyBool("shaderSampledImageArrayNonUniformIndexingNative",
+                   static_cast<bool>(obj.shaderSampledImageArrayNonUniformIndexingNative));
+    p.PrintKeyBool("shaderStorageBufferArrayNonUniformIndexingNative",
+                   static_cast<bool>(obj.shaderStorageBufferArrayNonUniformIndexingNative));
+    p.PrintKeyBool("shaderStorageImageArrayNonUniformIndexingNative",
+                   static_cast<bool>(obj.shaderStorageImageArrayNonUniformIndexingNative));
+    p.PrintKeyBool("shaderInputAttachmentArrayNonUniformIndexingNative",
+                   static_cast<bool>(obj.shaderInputAttachmentArrayNonUniformIndexingNative));
+    p.PrintKeyBool("robustBufferAccessUpdateAfterBind", static_cast<bool>(obj.robustBufferAccessUpdateAfterBind));
+    p.PrintKeyBool("quadDivergentImplicitLod", static_cast<bool>(obj.quadDivergentImplicitLod));
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindSamplers", obj.maxPerStageDescriptorUpdateAfterBindSamplers);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindUniformBuffers", obj.maxPerStageDescriptorUpdateAfterBindUniformBuffers);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindStorageBuffers", obj.maxPerStageDescriptorUpdateAfterBindStorageBuffers);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindSampledImages", obj.maxPerStageDescriptorUpdateAfterBindSampledImages);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindStorageImages", obj.maxPerStageDescriptorUpdateAfterBindStorageImages);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindInputAttachments",
+                    obj.maxPerStageDescriptorUpdateAfterBindInputAttachments);
+    p.PrintKeyValue("maxPerStageUpdateAfterBindResources", obj.maxPerStageUpdateAfterBindResources);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindSamplers", obj.maxDescriptorSetUpdateAfterBindSamplers);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindUniformBuffers", obj.maxDescriptorSetUpdateAfterBindUniformBuffers);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindUniformBuffersDynamic",
+                    obj.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageBuffers", obj.maxDescriptorSetUpdateAfterBindStorageBuffers);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageBuffersDynamic",
+                    obj.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindSampledImages", obj.maxDescriptorSetUpdateAfterBindSampledImages);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindStorageImages", obj.maxDescriptorSetUpdateAfterBindStorageImages);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindInputAttachments", obj.maxDescriptorSetUpdateAfterBindInputAttachments);
+    DumpVkResolveModeFlags(p, "supportedDepthResolveModes", obj.supportedDepthResolveModes);
+    DumpVkResolveModeFlags(p, "supportedStencilResolveModes", obj.supportedStencilResolveModes);
+    p.PrintKeyBool("independentResolveNone", static_cast<bool>(obj.independentResolveNone));
+    p.PrintKeyBool("independentResolve", static_cast<bool>(obj.independentResolve));
+    p.PrintKeyBool("filterMinmaxSingleComponentFormats", static_cast<bool>(obj.filterMinmaxSingleComponentFormats));
+    p.PrintKeyBool("filterMinmaxImageComponentMapping", static_cast<bool>(obj.filterMinmaxImageComponentMapping));
+    p.PrintKeyValue("maxTimelineSemaphoreValueDifference", obj.maxTimelineSemaphoreValueDifference);
+    DumpVkSampleCountFlags(p, "framebufferIntegerColorSampleCounts", obj.framebufferIntegerColorSampleCounts);
+}
+void DumpVkPhysicalDeviceVulkan13Features(Printer &p, std::string name, const VkPhysicalDeviceVulkan13Features &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(50);
+    p.PrintKeyBool("robustImageAccess", static_cast<bool>(obj.robustImageAccess));
+    p.PrintKeyBool("inlineUniformBlock", static_cast<bool>(obj.inlineUniformBlock));
+    p.PrintKeyBool("descriptorBindingInlineUniformBlockUpdateAfterBind",
+                   static_cast<bool>(obj.descriptorBindingInlineUniformBlockUpdateAfterBind));
+    p.PrintKeyBool("pipelineCreationCacheControl", static_cast<bool>(obj.pipelineCreationCacheControl));
+    p.PrintKeyBool("privateData", static_cast<bool>(obj.privateData));
+    p.PrintKeyBool("shaderDemoteToHelperInvocation", static_cast<bool>(obj.shaderDemoteToHelperInvocation));
+    p.PrintKeyBool("shaderTerminateInvocation", static_cast<bool>(obj.shaderTerminateInvocation));
+    p.PrintKeyBool("subgroupSizeControl", static_cast<bool>(obj.subgroupSizeControl));
+    p.PrintKeyBool("computeFullSubgroups", static_cast<bool>(obj.computeFullSubgroups));
+    p.PrintKeyBool("synchronization2", static_cast<bool>(obj.synchronization2));
+    p.PrintKeyBool("textureCompressionASTC_HDR", static_cast<bool>(obj.textureCompressionASTC_HDR));
+    p.PrintKeyBool("shaderZeroInitializeWorkgroupMemory", static_cast<bool>(obj.shaderZeroInitializeWorkgroupMemory));
+    p.PrintKeyBool("dynamicRendering", static_cast<bool>(obj.dynamicRendering));
+    p.PrintKeyBool("shaderIntegerDotProduct", static_cast<bool>(obj.shaderIntegerDotProduct));
+    p.PrintKeyBool("maintenance4", static_cast<bool>(obj.maintenance4));
+}
+void DumpVkPhysicalDeviceVulkan13Properties(Printer &p, std::string name, const VkPhysicalDeviceVulkan13Properties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(77);
+    p.PrintKeyValue("minSubgroupSize", obj.minSubgroupSize);
+    p.PrintKeyValue("maxSubgroupSize", obj.maxSubgroupSize);
+    p.PrintKeyValue("maxComputeWorkgroupSubgroups", obj.maxComputeWorkgroupSubgroups);
+    DumpVkShaderStageFlags(p, "requiredSubgroupSizeStages", obj.requiredSubgroupSizeStages);
+    p.PrintKeyValue("maxInlineUniformBlockSize", obj.maxInlineUniformBlockSize);
+    p.PrintKeyValue("maxPerStageDescriptorInlineUniformBlocks", obj.maxPerStageDescriptorInlineUniformBlocks);
+    p.PrintKeyValue("maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks",
+                    obj.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks);
+    p.PrintKeyValue("maxDescriptorSetInlineUniformBlocks", obj.maxDescriptorSetInlineUniformBlocks);
+    p.PrintKeyValue("maxDescriptorSetUpdateAfterBindInlineUniformBlocks", obj.maxDescriptorSetUpdateAfterBindInlineUniformBlocks);
+    p.PrintKeyValue("maxInlineUniformTotalSize", obj.maxInlineUniformTotalSize);
+    p.PrintKeyBool("integerDotProduct8BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct8BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProduct8BitSignedAccelerated", static_cast<bool>(obj.integerDotProduct8BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProduct8BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProduct8BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProduct4x8BitPackedUnsignedAccelerated",
+                   static_cast<bool>(obj.integerDotProduct4x8BitPackedUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProduct4x8BitPackedSignedAccelerated",
+                   static_cast<bool>(obj.integerDotProduct4x8BitPackedSignedAccelerated));
+    p.PrintKeyBool("integerDotProduct4x8BitPackedMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProduct4x8BitPackedMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProduct16BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct16BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProduct16BitSignedAccelerated", static_cast<bool>(obj.integerDotProduct16BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProduct16BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProduct16BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProduct32BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct32BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProduct32BitSignedAccelerated", static_cast<bool>(obj.integerDotProduct32BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProduct32BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProduct32BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProduct64BitUnsignedAccelerated", static_cast<bool>(obj.integerDotProduct64BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProduct64BitSignedAccelerated", static_cast<bool>(obj.integerDotProduct64BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProduct64BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProduct64BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating8BitUnsignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating8BitSignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating8BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating16BitUnsignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating16BitSignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating16BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating32BitUnsignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating32BitSignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating32BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating64BitUnsignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating64BitSignedAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating64BitSignedAccelerated));
+    p.PrintKeyBool("integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated",
+                   static_cast<bool>(obj.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated));
+    p.PrintKeyValue("storageTexelBufferOffsetAlignmentBytes", to_hex_str(p, obj.storageTexelBufferOffsetAlignmentBytes));
+    p.PrintKeyBool("storageTexelBufferOffsetSingleTexelAlignment",
+                   static_cast<bool>(obj.storageTexelBufferOffsetSingleTexelAlignment));
+    p.PrintKeyValue("uniformTexelBufferOffsetAlignmentBytes", to_hex_str(p, obj.uniformTexelBufferOffsetAlignmentBytes));
+    p.PrintKeyBool("uniformTexelBufferOffsetSingleTexelAlignment",
+                   static_cast<bool>(obj.uniformTexelBufferOffsetSingleTexelAlignment));
+    p.PrintKeyValue("maxBufferSize", to_hex_str(p, obj.maxBufferSize));
+}
+void DumpVkPhysicalDeviceVulkan14Features(Printer &p, std::string name, const VkPhysicalDeviceVulkan14Features &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(38);
+    p.PrintKeyBool("globalPriorityQuery", static_cast<bool>(obj.globalPriorityQuery));
+    p.PrintKeyBool("shaderSubgroupRotate", static_cast<bool>(obj.shaderSubgroupRotate));
+    p.PrintKeyBool("shaderSubgroupRotateClustered", static_cast<bool>(obj.shaderSubgroupRotateClustered));
+    p.PrintKeyBool("shaderFloatControls2", static_cast<bool>(obj.shaderFloatControls2));
+    p.PrintKeyBool("shaderExpectAssume", static_cast<bool>(obj.shaderExpectAssume));
+    p.PrintKeyBool("rectangularLines", static_cast<bool>(obj.rectangularLines));
+    p.PrintKeyBool("bresenhamLines", static_cast<bool>(obj.bresenhamLines));
+    p.PrintKeyBool("smoothLines", static_cast<bool>(obj.smoothLines));
+    p.PrintKeyBool("stippledRectangularLines", static_cast<bool>(obj.stippledRectangularLines));
+    p.PrintKeyBool("stippledBresenhamLines", static_cast<bool>(obj.stippledBresenhamLines));
+    p.PrintKeyBool("stippledSmoothLines", static_cast<bool>(obj.stippledSmoothLines));
+    p.PrintKeyBool("vertexAttributeInstanceRateDivisor", static_cast<bool>(obj.vertexAttributeInstanceRateDivisor));
+    p.PrintKeyBool("vertexAttributeInstanceRateZeroDivisor", static_cast<bool>(obj.vertexAttributeInstanceRateZeroDivisor));
+    p.PrintKeyBool("indexTypeUint8", static_cast<bool>(obj.indexTypeUint8));
+    p.PrintKeyBool("dynamicRenderingLocalRead", static_cast<bool>(obj.dynamicRenderingLocalRead));
+    p.PrintKeyBool("maintenance5", static_cast<bool>(obj.maintenance5));
+    p.PrintKeyBool("maintenance6", static_cast<bool>(obj.maintenance6));
+    p.PrintKeyBool("pipelineProtectedAccess", static_cast<bool>(obj.pipelineProtectedAccess));
+    p.PrintKeyBool("pipelineRobustness", static_cast<bool>(obj.pipelineRobustness));
+    p.PrintKeyBool("hostImageCopy", static_cast<bool>(obj.hostImageCopy));
+    p.PrintKeyBool("pushDescriptor", static_cast<bool>(obj.pushDescriptor));
+}
+void DumpVkPhysicalDeviceVulkan14Properties(Printer &p, std::string name, const VkPhysicalDeviceVulkan14Properties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(51);
+    p.PrintKeyValue("lineSubPixelPrecisionBits", obj.lineSubPixelPrecisionBits);
+    p.PrintKeyValue("maxVertexAttribDivisor", obj.maxVertexAttribDivisor);
+    p.PrintKeyBool("supportsNonZeroFirstInstance", static_cast<bool>(obj.supportsNonZeroFirstInstance));
+    p.PrintKeyValue("maxPushDescriptors", obj.maxPushDescriptors);
+    p.PrintKeyBool("dynamicRenderingLocalReadDepthStencilAttachments",
+                   static_cast<bool>(obj.dynamicRenderingLocalReadDepthStencilAttachments));
+    p.PrintKeyBool("dynamicRenderingLocalReadMultisampledAttachments",
+                   static_cast<bool>(obj.dynamicRenderingLocalReadMultisampledAttachments));
+    p.PrintKeyBool("earlyFragmentMultisampleCoverageAfterSampleCounting",
+                   static_cast<bool>(obj.earlyFragmentMultisampleCoverageAfterSampleCounting));
+    p.PrintKeyBool("earlyFragmentSampleMaskTestBeforeSampleCounting",
+                   static_cast<bool>(obj.earlyFragmentSampleMaskTestBeforeSampleCounting));
+    p.PrintKeyBool("depthStencilSwizzleOneSupport", static_cast<bool>(obj.depthStencilSwizzleOneSupport));
+    p.PrintKeyBool("polygonModePointSize", static_cast<bool>(obj.polygonModePointSize));
+    p.PrintKeyBool("nonStrictSinglePixelWideLinesUseParallelogram",
+                   static_cast<bool>(obj.nonStrictSinglePixelWideLinesUseParallelogram));
+    p.PrintKeyBool("nonStrictWideLinesUseParallelogram", static_cast<bool>(obj.nonStrictWideLinesUseParallelogram));
+    p.PrintKeyBool("blockTexelViewCompatibleMultipleLayers", static_cast<bool>(obj.blockTexelViewCompatibleMultipleLayers));
+    p.PrintKeyValue("maxCombinedImageSamplerDescriptorCount", obj.maxCombinedImageSamplerDescriptorCount);
+    p.PrintKeyBool("fragmentShadingRateClampCombinerInputs", static_cast<bool>(obj.fragmentShadingRateClampCombinerInputs));
+    DumpVkPipelineRobustnessBufferBehavior(p, "defaultRobustnessStorageBuffers", obj.defaultRobustnessStorageBuffers);
+    DumpVkPipelineRobustnessBufferBehavior(p, "defaultRobustnessUniformBuffers", obj.defaultRobustnessUniformBuffers);
+    DumpVkPipelineRobustnessBufferBehavior(p, "defaultRobustnessVertexInputs", obj.defaultRobustnessVertexInputs);
+    DumpVkPipelineRobustnessImageBehavior(p, "defaultRobustnessImages", obj.defaultRobustnessImages);
+    p.PrintKeyValue("copySrcLayoutCount", obj.copySrcLayoutCount);
+    if (obj.copySrcLayoutCount == 0 || obj.pCopySrcLayouts == nullptr) {
+        p.PrintKeyString("pCopySrcLayouts", "NULL");
+    } else {
+        ArrayWrapper arr(p, "pCopySrcLayouts", obj.copySrcLayoutCount);
+        for (uint32_t i = 0; i < obj.copySrcLayoutCount; i++) {
+            DumpVkImageLayout(p, std::to_string(i), obj.pCopySrcLayouts[i]);
+        }
+    }
+    p.PrintKeyValue("copyDstLayoutCount", obj.copyDstLayoutCount);
+    if (obj.copyDstLayoutCount == 0 || obj.pCopyDstLayouts == nullptr) {
+        p.PrintKeyString("pCopyDstLayouts", "NULL");
+    } else {
+        ArrayWrapper arr(p, "pCopyDstLayouts", obj.copyDstLayoutCount);
+        for (uint32_t i = 0; i < obj.copyDstLayoutCount; i++) {
+            DumpVkImageLayout(p, std::to_string(i), obj.pCopyDstLayouts[i]);
+        }
+    }
+    p.PrintKeyValue("optimalTilingLayoutUUID", obj.optimalTilingLayoutUUID);
+    p.PrintKeyBool("identicalMemoryTypeRequirements", static_cast<bool>(obj.identicalMemoryTypeRequirements));
+}
+void DumpVkPhysicalDeviceVulkanMemoryModelFeatures(Printer &p, std::string name,
+                                                   const VkPhysicalDeviceVulkanMemoryModelFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(45);
+    p.PrintKeyBool("vulkanMemoryModel", static_cast<bool>(obj.vulkanMemoryModel));
+    p.PrintKeyBool("vulkanMemoryModelDeviceScope", static_cast<bool>(obj.vulkanMemoryModelDeviceScope));
+    p.PrintKeyBool("vulkanMemoryModelAvailabilityVisibilityChains",
+                   static_cast<bool>(obj.vulkanMemoryModelAvailabilityVisibilityChains));
+}
+void DumpVkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
+    Printer &p, std::string name, const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(46);
+    p.PrintKeyBool("workgroupMemoryExplicitLayout", static_cast<bool>(obj.workgroupMemoryExplicitLayout));
+    p.PrintKeyBool("workgroupMemoryExplicitLayoutScalarBlockLayout",
+                   static_cast<bool>(obj.workgroupMemoryExplicitLayoutScalarBlockLayout));
+    p.PrintKeyBool("workgroupMemoryExplicitLayout8BitAccess", static_cast<bool>(obj.workgroupMemoryExplicitLayout8BitAccess));
+    p.PrintKeyBool("workgroupMemoryExplicitLayout16BitAccess", static_cast<bool>(obj.workgroupMemoryExplicitLayout16BitAccess));
+}
+void DumpVkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(Printer &p, std::string name,
+                                                          const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(21);
+    p.PrintKeyBool("ycbcr2plane444Formats", static_cast<bool>(obj.ycbcr2plane444Formats));
+}
+void DumpVkPhysicalDeviceYcbcrImageArraysFeaturesEXT(Printer &p, std::string name,
+                                                     const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(16);
+    p.PrintKeyBool("ycbcrImageArrays", static_cast<bool>(obj.ycbcrImageArrays));
+}
+void DumpVkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(26);
+    p.PrintKeyBool("zeroInitializeDeviceMemory", static_cast<bool>(obj.zeroInitializeDeviceMemory));
+}
+void DumpVkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(Printer &p, std::string name,
+                                                               const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(35);
+    p.PrintKeyBool("shaderZeroInitializeWorkgroupMemory", static_cast<bool>(obj.shaderZeroInitializeWorkgroupMemory));
+}
+void DumpVkPresentTimingSurfaceCapabilitiesEXT(Printer &p, std::string name, const VkPresentTimingSurfaceCapabilitiesEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(30);
+    p.PrintKeyBool("presentTimingSupported", static_cast<bool>(obj.presentTimingSupported));
+    p.PrintKeyBool("presentAtAbsoluteTimeSupported", static_cast<bool>(obj.presentAtAbsoluteTimeSupported));
+    p.PrintKeyBool("presentAtRelativeTimeSupported", static_cast<bool>(obj.presentAtRelativeTimeSupported));
+    DumpVkPresentStageFlagsEXT(p, "presentStageQueries", obj.presentStageQueries);
+}
+void DumpVkQueueFamilyGlobalPriorityProperties(Printer &p, std::string name, const VkQueueFamilyGlobalPriorityProperties &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(13);
+    p.PrintKeyValue("priorityCount", obj.priorityCount);
+    ArrayWrapper arr(p, "priorities", obj.priorityCount);
+    for (uint32_t i = 0; i < obj.priorityCount; i++) {
+        if (p.Type() == OutputType::json)
+            p.PrintString(std::string("VK_") + VkQueueGlobalPriorityString(obj.priorities[i]));
+        else
+            p.PrintString(VkQueueGlobalPriorityString(obj.priorities[i]));
+    }
+}
+void DumpVkQueueFamilyOwnershipTransferPropertiesKHR(Printer &p, std::string name,
+                                                     const VkQueueFamilyOwnershipTransferPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(35);
+    p.PrintKeyValue("optimalImageTransferToQueueFamilies", obj.optimalImageTransferToQueueFamilies);
+}
+void DumpVkQueueFamilyQueryResultStatusPropertiesKHR(Printer &p, std::string name,
+                                                     const VkQueueFamilyQueryResultStatusPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(24);
+    p.PrintKeyBool("queryResultStatusSupport", static_cast<bool>(obj.queryResultStatusSupport));
+}
+void DumpVkQueueFamilyVideoPropertiesKHR(Printer &p, std::string name, const VkQueueFamilyVideoPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkVideoCodecOperationFlagsKHR(p, "videoCodecOperations", obj.videoCodecOperations);
+}
+void DumpVkSharedPresentSurfaceCapabilitiesKHR(Printer &p, std::string name, const VkSharedPresentSurfaceCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkImageUsageFlags(p, "sharedPresentSupportedUsageFlags", obj.sharedPresentSupportedUsageFlags);
+}
+void DumpVkSubpassResolvePerformanceQueryEXT(Printer &p, std::string name, const VkSubpassResolvePerformanceQueryEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(7);
+    p.PrintKeyBool("optimal", static_cast<bool>(obj.optimal));
+}
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+void DumpVkSurfaceCapabilitiesFullScreenExclusiveEXT(Printer &p, std::string name,
+                                                     const VkSurfaceCapabilitiesFullScreenExclusiveEXT &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(28);
+    p.PrintKeyBool("fullScreenExclusiveSupported", static_cast<bool>(obj.fullScreenExclusiveSupported));
+}
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+void DumpVkSurfaceCapabilitiesKHR(Printer &p, std::string name, const VkSurfaceCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(19);
+    p.PrintKeyValue("minImageCount", obj.minImageCount);
+    p.PrintKeyValue("maxImageCount", obj.maxImageCount);
+    DumpVkExtent2D(p, "currentExtent", obj.currentExtent);
+    DumpVkExtent2D(p, "minImageExtent", obj.minImageExtent);
+    DumpVkExtent2D(p, "maxImageExtent", obj.maxImageExtent);
+    p.PrintKeyValue("maxImageArrayLayers", obj.maxImageArrayLayers);
+    DumpVkSurfaceTransformFlagsKHR(p, "supportedTransforms", obj.supportedTransforms);
+    DumpVkSurfaceTransformFlagBitsKHR(p, "currentTransform", obj.currentTransform);
+    DumpVkCompositeAlphaFlagsKHR(p, "supportedCompositeAlpha", obj.supportedCompositeAlpha);
+    DumpVkImageUsageFlags(p, "supportedUsageFlags", obj.supportedUsageFlags);
+}
+void DumpVkSurfaceCapabilitiesPresentId2KHR(Printer &p, std::string name, const VkSurfaceCapabilitiesPresentId2KHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(19);
+    p.PrintKeyBool("presentId2Supported", static_cast<bool>(obj.presentId2Supported));
+}
+void DumpVkSurfaceCapabilitiesPresentWait2KHR(Printer &p, std::string name, const VkSurfaceCapabilitiesPresentWait2KHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(21);
+    p.PrintKeyBool("presentWait2Supported", static_cast<bool>(obj.presentWait2Supported));
+}
+void DumpVkSurfaceFormatKHR(Printer &p, std::string name, const VkSurfaceFormatKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkFormat(p, "format", obj.format);
+    DumpVkColorSpaceKHR(p, "colorSpace", obj.colorSpace);
+}
+void DumpVkSurfacePresentModeCompatibilityKHR(Printer &p, std::string name, const VkSurfacePresentModeCompatibilityKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(16);
+    p.PrintKeyValue("presentModeCount", obj.presentModeCount);
+    if (obj.presentModeCount == 0 || obj.pPresentModes == nullptr) {
+        p.PrintKeyString("pPresentModes", "NULL");
+    } else {
+        ArrayWrapper arr(p, "pPresentModes", obj.presentModeCount);
+        for (uint32_t i = 0; i < obj.presentModeCount; i++) {
+            DumpVkPresentModeKHR(p, std::to_string(i), obj.pPresentModes[i]);
+        }
+    }
+}
+void DumpVkSurfacePresentScalingCapabilitiesKHR(Printer &p, std::string name, const VkSurfacePresentScalingCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkPresentScalingFlagsKHR(p, "supportedPresentScaling", obj.supportedPresentScaling);
+    DumpVkPresentGravityFlagsKHR(p, "supportedPresentGravityX", obj.supportedPresentGravityX);
+    DumpVkPresentGravityFlagsKHR(p, "supportedPresentGravityY", obj.supportedPresentGravityY);
+    DumpVkExtent2D(p, "minScaledImageExtent", obj.minScaledImageExtent);
+    DumpVkExtent2D(p, "maxScaledImageExtent", obj.maxScaledImageExtent);
+}
+void DumpVkSurfaceProtectedCapabilitiesKHR(Printer &p, std::string name, const VkSurfaceProtectedCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(17);
+    p.PrintKeyBool("supportsProtected", static_cast<bool>(obj.supportsProtected));
+}
+void DumpVkVideoCapabilitiesKHR(Printer &p, std::string name, const VkVideoCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(33);
+    DumpVkVideoCapabilityFlagsKHR(p, "flags", obj.flags);
+    p.PrintKeyValue("minBitstreamBufferOffsetAlignment", to_hex_str(p, obj.minBitstreamBufferOffsetAlignment));
+    p.PrintKeyValue("minBitstreamBufferSizeAlignment", to_hex_str(p, obj.minBitstreamBufferSizeAlignment));
+    DumpVkExtent2D(p, "pictureAccessGranularity", obj.pictureAccessGranularity);
+    DumpVkExtent2D(p, "minCodedExtent", obj.minCodedExtent);
+    DumpVkExtent2D(p, "maxCodedExtent", obj.maxCodedExtent);
+    p.PrintKeyValue("maxDpbSlots", obj.maxDpbSlots);
+    p.PrintKeyValue("maxActiveReferencePictures", obj.maxActiveReferencePictures);
+    DumpVkExtensionProperties(p, "stdHeaderVersion", obj.stdHeaderVersion);
+}
+void DumpVkVideoDecodeAV1CapabilitiesKHR(Printer &p, std::string name, const VkVideoDecodeAV1CapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpStdVideoAV1Level(p, "maxLevel", obj.maxLevel);
+}
+void DumpVkVideoDecodeAV1ProfileInfoKHR(Printer &p, std::string name, const VkVideoDecodeAV1ProfileInfoKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(16);
+    DumpStdVideoAV1Profile(p, "stdProfile", obj.stdProfile);
+    p.PrintKeyBool("filmGrainSupport", static_cast<bool>(obj.filmGrainSupport));
+}
+void DumpVkVideoDecodeCapabilitiesKHR(Printer &p, std::string name, const VkVideoDecodeCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkVideoDecodeCapabilityFlagsKHR(p, "flags", obj.flags);
+}
+void DumpVkVideoDecodeH264CapabilitiesKHR(Printer &p, std::string name, const VkVideoDecodeH264CapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpStdVideoH264LevelIdc(p, "maxLevelIdc", obj.maxLevelIdc);
+    DumpVkOffset2D(p, "fieldOffsetGranularity", obj.fieldOffsetGranularity);
+}
+void DumpVkVideoDecodeH264ProfileInfoKHR(Printer &p, std::string name, const VkVideoDecodeH264ProfileInfoKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpStdVideoH264ProfileIdc(p, "stdProfileIdc", obj.stdProfileIdc);
+    DumpVkVideoDecodeH264PictureLayoutFlagBitsKHR(p, "pictureLayout", obj.pictureLayout);
+}
+void DumpVkVideoDecodeH265CapabilitiesKHR(Printer &p, std::string name, const VkVideoDecodeH265CapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpStdVideoH265LevelIdc(p, "maxLevelIdc", obj.maxLevelIdc);
+}
+void DumpVkVideoDecodeH265ProfileInfoKHR(Printer &p, std::string name, const VkVideoDecodeH265ProfileInfoKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpStdVideoH265ProfileIdc(p, "stdProfileIdc", obj.stdProfileIdc);
+}
+void DumpVkVideoDecodeUsageInfoKHR(Printer &p, std::string name, const VkVideoDecodeUsageInfoKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkVideoDecodeUsageFlagsKHR(p, "videoUsageHints", obj.videoUsageHints);
+}
+void DumpVkVideoDecodeVP9CapabilitiesKHR(Printer &p, std::string name, const VkVideoDecodeVP9CapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpStdVideoVP9Level(p, "maxLevel", obj.maxLevel);
+}
+void DumpVkVideoDecodeVP9ProfileInfoKHR(Printer &p, std::string name, const VkVideoDecodeVP9ProfileInfoKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpStdVideoVP9Profile(p, "stdProfile", obj.stdProfile);
+}
+void DumpVkVideoEncodeAV1CapabilitiesKHR(Printer &p, std::string name, const VkVideoEncodeAV1CapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(45);
+    DumpVkVideoEncodeAV1CapabilityFlagsKHR(p, "flags", obj.flags);
+    DumpStdVideoAV1Level(p, "maxLevel", obj.maxLevel);
+    DumpVkExtent2D(p, "codedPictureAlignment", obj.codedPictureAlignment);
+    DumpVkExtent2D(p, "maxTiles", obj.maxTiles);
+    DumpVkExtent2D(p, "minTileSize", obj.minTileSize);
+    DumpVkExtent2D(p, "maxTileSize", obj.maxTileSize);
+    DumpVkVideoEncodeAV1SuperblockSizeFlagsKHR(p, "superblockSizes", obj.superblockSizes);
+    p.PrintKeyValue("maxSingleReferenceCount", obj.maxSingleReferenceCount);
+    p.PrintKeyValue("singleReferenceNameMask", obj.singleReferenceNameMask);
+    p.PrintKeyValue("maxUnidirectionalCompoundReferenceCount", obj.maxUnidirectionalCompoundReferenceCount);
+    p.PrintKeyValue("maxUnidirectionalCompoundGroup1ReferenceCount", obj.maxUnidirectionalCompoundGroup1ReferenceCount);
+    p.PrintKeyValue("unidirectionalCompoundReferenceNameMask", obj.unidirectionalCompoundReferenceNameMask);
+    p.PrintKeyValue("maxBidirectionalCompoundReferenceCount", obj.maxBidirectionalCompoundReferenceCount);
+    p.PrintKeyValue("maxBidirectionalCompoundGroup1ReferenceCount", obj.maxBidirectionalCompoundGroup1ReferenceCount);
+    p.PrintKeyValue("maxBidirectionalCompoundGroup2ReferenceCount", obj.maxBidirectionalCompoundGroup2ReferenceCount);
+    p.PrintKeyValue("bidirectionalCompoundReferenceNameMask", obj.bidirectionalCompoundReferenceNameMask);
+    p.PrintKeyValue("maxTemporalLayerCount", obj.maxTemporalLayerCount);
+    p.PrintKeyValue("maxSpatialLayerCount", obj.maxSpatialLayerCount);
+    p.PrintKeyValue("maxOperatingPoints", obj.maxOperatingPoints);
+    p.PrintKeyValue("minQIndex", obj.minQIndex);
+    p.PrintKeyValue("maxQIndex", obj.maxQIndex);
+    p.PrintKeyBool("prefersGopRemainingFrames", static_cast<bool>(obj.prefersGopRemainingFrames));
+    p.PrintKeyBool("requiresGopRemainingFrames", static_cast<bool>(obj.requiresGopRemainingFrames));
+    DumpVkVideoEncodeAV1StdFlagsKHR(p, "stdSyntaxFlags", obj.stdSyntaxFlags);
+}
+void DumpVkVideoEncodeAV1ProfileInfoKHR(Printer &p, std::string name, const VkVideoEncodeAV1ProfileInfoKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpStdVideoAV1Profile(p, "stdProfile", obj.stdProfile);
+}
+void DumpVkVideoEncodeAV1QuantizationMapCapabilitiesKHR(Printer &p, std::string name,
+                                                        const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(14);
+    p.PrintKeyValue("minQIndexDelta", obj.minQIndexDelta);
+    p.PrintKeyValue("maxQIndexDelta", obj.maxQIndexDelta);
+}
+void DumpVkVideoEncodeCapabilitiesKHR(Printer &p, std::string name, const VkVideoEncodeCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(20);
+    DumpVkVideoEncodeCapabilityFlagsKHR(p, "flags", obj.flags);
+    DumpVkVideoEncodeRateControlModeFlagsKHR(p, "rateControlModes", obj.rateControlModes);
+    p.PrintKeyValue("maxRateControlLayers", obj.maxRateControlLayers);
+    p.PrintKeyValue("maxBitrate", obj.maxBitrate);
+    p.PrintKeyValue("maxQualityLevels", obj.maxQualityLevels);
+    DumpVkExtent2D(p, "encodeInputPictureGranularity", obj.encodeInputPictureGranularity);
+    DumpVkVideoEncodeFeedbackFlagsKHR(p, "supportedEncodeFeedbackFlags", obj.supportedEncodeFeedbackFlags);
+}
+void DumpVkVideoEncodeH264CapabilitiesKHR(Printer &p, std::string name, const VkVideoEncodeH264CapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(32);
+    DumpVkVideoEncodeH264CapabilityFlagsKHR(p, "flags", obj.flags);
+    DumpStdVideoH264LevelIdc(p, "maxLevelIdc", obj.maxLevelIdc);
+    p.PrintKeyValue("maxSliceCount", obj.maxSliceCount);
+    p.PrintKeyValue("maxPPictureL0ReferenceCount", obj.maxPPictureL0ReferenceCount);
+    p.PrintKeyValue("maxBPictureL0ReferenceCount", obj.maxBPictureL0ReferenceCount);
+    p.PrintKeyValue("maxL1ReferenceCount", obj.maxL1ReferenceCount);
+    p.PrintKeyValue("maxTemporalLayerCount", obj.maxTemporalLayerCount);
+    p.PrintKeyBool("expectDyadicTemporalLayerPattern", static_cast<bool>(obj.expectDyadicTemporalLayerPattern));
+    p.PrintKeyValue("minQp", obj.minQp);
+    p.PrintKeyValue("maxQp", obj.maxQp);
+    p.PrintKeyBool("prefersGopRemainingFrames", static_cast<bool>(obj.prefersGopRemainingFrames));
+    p.PrintKeyBool("requiresGopRemainingFrames", static_cast<bool>(obj.requiresGopRemainingFrames));
+    DumpVkVideoEncodeH264StdFlagsKHR(p, "stdSyntaxFlags", obj.stdSyntaxFlags);
+}
+void DumpVkVideoEncodeH264ProfileInfoKHR(Printer &p, std::string name, const VkVideoEncodeH264ProfileInfoKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpStdVideoH264ProfileIdc(p, "stdProfileIdc", obj.stdProfileIdc);
+}
+void DumpVkVideoEncodeH264QuantizationMapCapabilitiesKHR(Printer &p, std::string name,
+                                                         const VkVideoEncodeH264QuantizationMapCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(10);
+    p.PrintKeyValue("minQpDelta", obj.minQpDelta);
+    p.PrintKeyValue("maxQpDelta", obj.maxQpDelta);
+}
+void DumpVkVideoEncodeH265CapabilitiesKHR(Printer &p, std::string name, const VkVideoEncodeH265CapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(35);
+    DumpVkVideoEncodeH265CapabilityFlagsKHR(p, "flags", obj.flags);
+    DumpStdVideoH265LevelIdc(p, "maxLevelIdc", obj.maxLevelIdc);
+    p.PrintKeyValue("maxSliceSegmentCount", obj.maxSliceSegmentCount);
+    DumpVkExtent2D(p, "maxTiles", obj.maxTiles);
+    DumpVkVideoEncodeH265CtbSizeFlagsKHR(p, "ctbSizes", obj.ctbSizes);
+    DumpVkVideoEncodeH265TransformBlockSizeFlagsKHR(p, "transformBlockSizes", obj.transformBlockSizes);
+    p.PrintKeyValue("maxPPictureL0ReferenceCount", obj.maxPPictureL0ReferenceCount);
+    p.PrintKeyValue("maxBPictureL0ReferenceCount", obj.maxBPictureL0ReferenceCount);
+    p.PrintKeyValue("maxL1ReferenceCount", obj.maxL1ReferenceCount);
+    p.PrintKeyValue("maxSubLayerCount", obj.maxSubLayerCount);
+    p.PrintKeyBool("expectDyadicTemporalSubLayerPattern", static_cast<bool>(obj.expectDyadicTemporalSubLayerPattern));
+    p.PrintKeyValue("minQp", obj.minQp);
+    p.PrintKeyValue("maxQp", obj.maxQp);
+    p.PrintKeyBool("prefersGopRemainingFrames", static_cast<bool>(obj.prefersGopRemainingFrames));
+    p.PrintKeyBool("requiresGopRemainingFrames", static_cast<bool>(obj.requiresGopRemainingFrames));
+    DumpVkVideoEncodeH265StdFlagsKHR(p, "stdSyntaxFlags", obj.stdSyntaxFlags);
+}
+void DumpVkVideoEncodeH265ProfileInfoKHR(Printer &p, std::string name, const VkVideoEncodeH265ProfileInfoKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpStdVideoH265ProfileIdc(p, "stdProfileIdc", obj.stdProfileIdc);
+}
+void DumpVkVideoEncodeH265QuantizationMapCapabilitiesKHR(Printer &p, std::string name,
+                                                         const VkVideoEncodeH265QuantizationMapCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(10);
+    p.PrintKeyValue("minQpDelta", obj.minQpDelta);
+    p.PrintKeyValue("maxQpDelta", obj.maxQpDelta);
+}
+void DumpVkVideoEncodeIntraRefreshCapabilitiesKHR(Printer &p, std::string name,
+                                                  const VkVideoEncodeIntraRefreshCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(39);
+    DumpVkVideoEncodeIntraRefreshModeFlagsKHR(p, "intraRefreshModes", obj.intraRefreshModes);
+    p.PrintKeyValue("maxIntraRefreshCycleDuration", obj.maxIntraRefreshCycleDuration);
+    p.PrintKeyValue("maxIntraRefreshActiveReferencePictures", obj.maxIntraRefreshActiveReferencePictures);
+    p.PrintKeyBool("partitionIndependentIntraRefreshRegions", static_cast<bool>(obj.partitionIndependentIntraRefreshRegions));
+    p.PrintKeyBool("nonRectangularIntraRefreshRegions", static_cast<bool>(obj.nonRectangularIntraRefreshRegions));
+}
+void DumpVkVideoEncodeProfileRgbConversionInfoVALVE(Printer &p, std::string name,
+                                                    const VkVideoEncodeProfileRgbConversionInfoVALVE &obj) {
+    ObjectWrapper object{p, name};
+    p.SetMinKeyWidth(26);
+    p.PrintKeyBool("performEncodeRgbConversion", static_cast<bool>(obj.performEncodeRgbConversion));
+}
+void DumpVkVideoEncodeQuantizationMapCapabilitiesKHR(Printer &p, std::string name,
+                                                     const VkVideoEncodeQuantizationMapCapabilitiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkExtent2D(p, "maxQuantizationMapExtent", obj.maxQuantizationMapExtent);
+}
+void DumpVkVideoEncodeRgbConversionCapabilitiesVALVE(Printer &p, std::string name,
+                                                     const VkVideoEncodeRgbConversionCapabilitiesVALVE &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkVideoEncodeRgbModelConversionFlagsVALVE(p, "rgbModels", obj.rgbModels);
+    DumpVkVideoEncodeRgbRangeCompressionFlagsVALVE(p, "rgbRanges", obj.rgbRanges);
+    DumpVkVideoEncodeRgbChromaOffsetFlagsVALVE(p, "xChromaOffsets", obj.xChromaOffsets);
+    DumpVkVideoEncodeRgbChromaOffsetFlagsVALVE(p, "yChromaOffsets", obj.yChromaOffsets);
+}
+void DumpVkVideoEncodeUsageInfoKHR(Printer &p, std::string name, const VkVideoEncodeUsageInfoKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkVideoEncodeUsageFlagsKHR(p, "videoUsageHints", obj.videoUsageHints);
+    DumpVkVideoEncodeContentFlagsKHR(p, "videoContentHints", obj.videoContentHints);
+    DumpVkVideoEncodeTuningModeKHR(p, "tuningMode", obj.tuningMode);
+}
+void DumpVkVideoFormatAV1QuantizationMapPropertiesKHR(Printer &p, std::string name,
+                                                      const VkVideoFormatAV1QuantizationMapPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkVideoEncodeAV1SuperblockSizeFlagsKHR(p, "compatibleSuperblockSizes", obj.compatibleSuperblockSizes);
+}
+void DumpVkVideoFormatH265QuantizationMapPropertiesKHR(Printer &p, std::string name,
+                                                       const VkVideoFormatH265QuantizationMapPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkVideoEncodeH265CtbSizeFlagsKHR(p, "compatibleCtbSizes", obj.compatibleCtbSizes);
+}
+void DumpVkVideoFormatPropertiesKHR(Printer &p, std::string name, const VkVideoFormatPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkFormat(p, "format", obj.format);
+    DumpVkComponentMapping(p, "componentMapping", obj.componentMapping);
+    DumpVkImageCreateFlags(p, "imageCreateFlags", obj.imageCreateFlags);
+    DumpVkImageType(p, "imageType", obj.imageType);
+    DumpVkImageTiling(p, "imageTiling", obj.imageTiling);
+    DumpVkImageUsageFlags(p, "imageUsageFlags", obj.imageUsageFlags);
+}
+void DumpVkVideoFormatQuantizationMapPropertiesKHR(Printer &p, std::string name,
+                                                   const VkVideoFormatQuantizationMapPropertiesKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkExtent2D(p, "quantizationMapTexelSize", obj.quantizationMapTexelSize);
+}
+void DumpVkVideoProfileInfoKHR(Printer &p, std::string name, const VkVideoProfileInfoKHR &obj) {
+    ObjectWrapper object{p, name};
+    DumpVkVideoCodecOperationFlagBitsKHR(p, "videoCodecOperation", obj.videoCodecOperation);
+    DumpVkVideoChromaSubsamplingFlagsKHR(p, "chromaSubsampling", obj.chromaSubsampling);
+    DumpVkVideoComponentBitDepthFlagsKHR(p, "lumaBitDepth", obj.lumaBitDepth);
+    DumpVkVideoComponentBitDepthFlagsKHR(p, "chromaBitDepth", obj.chromaBitDepth);
+}
+struct phys_device_props2_chain {
+    phys_device_props2_chain() = default;
+    phys_device_props2_chain(const phys_device_props2_chain &) = delete;
+    phys_device_props2_chain &operator=(const phys_device_props2_chain &) = delete;
+    phys_device_props2_chain(phys_device_props2_chain &&) = delete;
+    phys_device_props2_chain &operator=(phys_device_props2_chain &&) = delete;
+    void *start_of_chain = nullptr;
+    VkPhysicalDeviceAccelerationStructurePropertiesKHR PhysicalDeviceAccelerationStructurePropertiesKHR{};
+    VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT PhysicalDeviceBlendOperationAdvancedPropertiesEXT{};
+    VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR PhysicalDeviceComputeShaderDerivativesPropertiesKHR{};
+    VkPhysicalDeviceConservativeRasterizationPropertiesEXT PhysicalDeviceConservativeRasterizationPropertiesEXT{};
+    VkPhysicalDeviceCooperativeMatrixPropertiesKHR PhysicalDeviceCooperativeMatrixPropertiesKHR{};
+    VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR PhysicalDeviceCopyMemoryIndirectPropertiesKHR{};
+    VkPhysicalDeviceCustomBorderColorPropertiesEXT PhysicalDeviceCustomBorderColorPropertiesEXT{};
+    VkPhysicalDeviceDepthStencilResolveProperties PhysicalDeviceDepthStencilResolveProperties{};
+    VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT{};
+    VkPhysicalDeviceDescriptorBufferPropertiesEXT PhysicalDeviceDescriptorBufferPropertiesEXT{};
+    VkPhysicalDeviceDescriptorHeapPropertiesEXT PhysicalDeviceDescriptorHeapPropertiesEXT{};
+    VkPhysicalDeviceDescriptorHeapTensorPropertiesARM PhysicalDeviceDescriptorHeapTensorPropertiesARM{};
+    VkPhysicalDeviceDescriptorIndexingProperties PhysicalDeviceDescriptorIndexingProperties{};
+    VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT{};
+    VkPhysicalDeviceDiscardRectanglePropertiesEXT PhysicalDeviceDiscardRectanglePropertiesEXT{};
+    VkPhysicalDeviceDriverProperties PhysicalDeviceDriverProperties{};
+    VkPhysicalDeviceDrmPropertiesEXT PhysicalDeviceDrmPropertiesEXT{};
+    VkPhysicalDeviceExtendedDynamicState3PropertiesEXT PhysicalDeviceExtendedDynamicState3PropertiesEXT{};
+    VkPhysicalDeviceExternalMemoryHostPropertiesEXT PhysicalDeviceExternalMemoryHostPropertiesEXT{};
+    VkPhysicalDeviceFaultPropertiesKHR PhysicalDeviceFaultPropertiesKHR{};
+    VkPhysicalDeviceFloatControlsProperties PhysicalDeviceFloatControlsProperties{};
+    VkPhysicalDeviceFragmentDensityMap2PropertiesEXT PhysicalDeviceFragmentDensityMap2PropertiesEXT{};
+    VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT{};
+    VkPhysicalDeviceFragmentDensityMapPropertiesEXT PhysicalDeviceFragmentDensityMapPropertiesEXT{};
+    VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR PhysicalDeviceFragmentShaderBarycentricPropertiesKHR{};
+    VkPhysicalDeviceFragmentShadingRatePropertiesKHR PhysicalDeviceFragmentShadingRatePropertiesKHR{};
+    VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT{};
+    VkPhysicalDeviceHostImageCopyProperties PhysicalDeviceHostImageCopyProperties{};
+    std::vector<VkImageLayout> VkPhysicalDeviceHostImageCopyProperties_pCopySrcLayouts;
+    std::vector<VkImageLayout> VkPhysicalDeviceHostImageCopyProperties_pCopyDstLayouts;
+    VkPhysicalDeviceIDProperties PhysicalDeviceIDProperties{};
+    VkPhysicalDeviceInlineUniformBlockProperties PhysicalDeviceInlineUniformBlockProperties{};
+    VkPhysicalDeviceLayeredApiPropertiesListKHR PhysicalDeviceLayeredApiPropertiesListKHR{};
+    std::vector<VkPhysicalDeviceLayeredApiPropertiesKHR> VkPhysicalDeviceLayeredApiPropertiesListKHR_pLayeredApis;
+    VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT PhysicalDeviceLegacyVertexAttributesPropertiesEXT{};
+    VkPhysicalDeviceLineRasterizationProperties PhysicalDeviceLineRasterizationProperties{};
+    VkPhysicalDeviceMaintenance10PropertiesKHR PhysicalDeviceMaintenance10PropertiesKHR{};
+    VkPhysicalDeviceMaintenance3Properties PhysicalDeviceMaintenance3Properties{};
+    VkPhysicalDeviceMaintenance4Properties PhysicalDeviceMaintenance4Properties{};
+    VkPhysicalDeviceMaintenance5Properties PhysicalDeviceMaintenance5Properties{};
+    VkPhysicalDeviceMaintenance6Properties PhysicalDeviceMaintenance6Properties{};
+    VkPhysicalDeviceMaintenance7PropertiesKHR PhysicalDeviceMaintenance7PropertiesKHR{};
+    VkPhysicalDeviceMaintenance9PropertiesKHR PhysicalDeviceMaintenance9PropertiesKHR{};
+    VkPhysicalDeviceMapMemoryPlacedPropertiesEXT PhysicalDeviceMapMemoryPlacedPropertiesEXT{};
+    VkPhysicalDeviceMemoryDecompressionPropertiesEXT PhysicalDeviceMemoryDecompressionPropertiesEXT{};
+    VkPhysicalDeviceMeshShaderPropertiesEXT PhysicalDeviceMeshShaderPropertiesEXT{};
+    VkPhysicalDeviceMultiDrawPropertiesEXT PhysicalDeviceMultiDrawPropertiesEXT{};
+    VkPhysicalDeviceMultiviewProperties PhysicalDeviceMultiviewProperties{};
+    VkPhysicalDeviceNestedCommandBufferPropertiesEXT PhysicalDeviceNestedCommandBufferPropertiesEXT{};
+    VkPhysicalDeviceOpacityMicromapPropertiesEXT PhysicalDeviceOpacityMicromapPropertiesEXT{};
+    VkPhysicalDevicePCIBusInfoPropertiesEXT PhysicalDevicePCIBusInfoPropertiesEXT{};
+    VkPhysicalDevicePerformanceQueryPropertiesKHR PhysicalDevicePerformanceQueryPropertiesKHR{};
+    VkPhysicalDevicePipelineBinaryPropertiesKHR PhysicalDevicePipelineBinaryPropertiesKHR{};
+    VkPhysicalDevicePipelineRobustnessProperties PhysicalDevicePipelineRobustnessProperties{};
+    VkPhysicalDevicePointClippingProperties PhysicalDevicePointClippingProperties{};
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VkPhysicalDevicePortabilitySubsetPropertiesKHR PhysicalDevicePortabilitySubsetPropertiesKHR{};
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+    VkPhysicalDeviceProtectedMemoryProperties PhysicalDeviceProtectedMemoryProperties{};
+    VkPhysicalDeviceProvokingVertexPropertiesEXT PhysicalDeviceProvokingVertexPropertiesEXT{};
+    VkPhysicalDevicePushDescriptorProperties PhysicalDevicePushDescriptorProperties{};
+    VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT PhysicalDeviceRayTracingInvocationReorderPropertiesEXT{};
+    VkPhysicalDeviceRayTracingPipelinePropertiesKHR PhysicalDeviceRayTracingPipelinePropertiesKHR{};
+    VkPhysicalDeviceRobustness2PropertiesKHR PhysicalDeviceRobustness2PropertiesKHR{};
+    VkPhysicalDeviceSampleLocationsPropertiesEXT PhysicalDeviceSampleLocationsPropertiesEXT{};
+    VkPhysicalDeviceSamplerFilterMinmaxProperties PhysicalDeviceSamplerFilterMinmaxProperties{};
+    VkPhysicalDeviceShaderAbortPropertiesKHR PhysicalDeviceShaderAbortPropertiesKHR{};
+    VkPhysicalDeviceShaderIntegerDotProductProperties PhysicalDeviceShaderIntegerDotProductProperties{};
+    VkPhysicalDeviceShaderLongVectorPropertiesEXT PhysicalDeviceShaderLongVectorPropertiesEXT{};
+    VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT PhysicalDeviceShaderModuleIdentifierPropertiesEXT{};
+    VkPhysicalDeviceShaderObjectPropertiesEXT PhysicalDeviceShaderObjectPropertiesEXT{};
+    VkPhysicalDeviceShaderTileImagePropertiesEXT PhysicalDeviceShaderTileImagePropertiesEXT{};
+    VkPhysicalDeviceSubgroupProperties PhysicalDeviceSubgroupProperties{};
+    VkPhysicalDeviceSubgroupSizeControlProperties PhysicalDeviceSubgroupSizeControlProperties{};
+    VkPhysicalDeviceTexelBufferAlignmentProperties PhysicalDeviceTexelBufferAlignmentProperties{};
+    VkPhysicalDeviceTimelineSemaphoreProperties PhysicalDeviceTimelineSemaphoreProperties{};
+    VkPhysicalDeviceTransformFeedbackPropertiesEXT PhysicalDeviceTransformFeedbackPropertiesEXT{};
+    VkPhysicalDeviceVertexAttributeDivisorProperties PhysicalDeviceVertexAttributeDivisorProperties{};
+    VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT PhysicalDeviceVertexAttributeDivisorPropertiesEXT{};
+    VkPhysicalDeviceVulkan11Properties PhysicalDeviceVulkan11Properties{};
+    VkPhysicalDeviceVulkan12Properties PhysicalDeviceVulkan12Properties{};
+    VkPhysicalDeviceVulkan13Properties PhysicalDeviceVulkan13Properties{};
+    VkPhysicalDeviceVulkan14Properties PhysicalDeviceVulkan14Properties{};
+    std::vector<VkImageLayout> VkPhysicalDeviceVulkan14Properties_pCopySrcLayouts;
+    std::vector<VkImageLayout> VkPhysicalDeviceVulkan14Properties_pCopyDstLayouts;
+    void initialize_chain(AppInstance &inst, AppGpu &gpu, bool show_promoted_structs) noexcept {
+        PhysicalDeviceAccelerationStructurePropertiesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;
+        PhysicalDeviceBlendOperationAdvancedPropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT;
+        PhysicalDeviceComputeShaderDerivativesPropertiesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR;
+        PhysicalDeviceConservativeRasterizationPropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT;
+        PhysicalDeviceCooperativeMatrixPropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR;
+        PhysicalDeviceCopyMemoryIndirectPropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR;
+        PhysicalDeviceCustomBorderColorPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT;
+        PhysicalDeviceDepthStencilResolveProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
+        PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT;
+        PhysicalDeviceDescriptorBufferPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT;
+        PhysicalDeviceDescriptorHeapPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT;
+        PhysicalDeviceDescriptorHeapTensorPropertiesARM.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM;
+        PhysicalDeviceDescriptorIndexingProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
+        PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT;
+        PhysicalDeviceDiscardRectanglePropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT;
+        PhysicalDeviceDriverProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
+        PhysicalDeviceDrmPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT;
+        PhysicalDeviceExtendedDynamicState3PropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT;
+        PhysicalDeviceExternalMemoryHostPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
+        PhysicalDeviceFaultPropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_PROPERTIES_KHR;
+        PhysicalDeviceFloatControlsProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
+        PhysicalDeviceFragmentDensityMap2PropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT;
+        PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT;
+        PhysicalDeviceFragmentDensityMapPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
+        PhysicalDeviceFragmentShaderBarycentricPropertiesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR;
+        PhysicalDeviceFragmentShadingRatePropertiesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
+        PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT;
+        PhysicalDeviceHostImageCopyProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES;
+        PhysicalDeviceIDProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
+        PhysicalDeviceInlineUniformBlockProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
+        PhysicalDeviceLayeredApiPropertiesListKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR;
+        PhysicalDeviceLegacyVertexAttributesPropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT;
+        PhysicalDeviceLineRasterizationProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES;
+        PhysicalDeviceMaintenance10PropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR;
+        PhysicalDeviceMaintenance3Properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
+        PhysicalDeviceMaintenance4Properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
+        PhysicalDeviceMaintenance5Properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES;
+        PhysicalDeviceMaintenance6Properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES;
+        PhysicalDeviceMaintenance7PropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR;
+        PhysicalDeviceMaintenance9PropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR;
+        PhysicalDeviceMapMemoryPlacedPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT;
+        PhysicalDeviceMemoryDecompressionPropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT;
+        PhysicalDeviceMeshShaderPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT;
+        PhysicalDeviceMultiDrawPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT;
+        PhysicalDeviceMultiviewProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
+        PhysicalDeviceNestedCommandBufferPropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT;
+        PhysicalDeviceOpacityMicromapPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT;
+        PhysicalDevicePCIBusInfoPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT;
+        PhysicalDevicePerformanceQueryPropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR;
+        PhysicalDevicePipelineBinaryPropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR;
+        PhysicalDevicePipelineRobustnessProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES;
+        PhysicalDevicePointClippingProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        PhysicalDevicePortabilitySubsetPropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR;
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+        PhysicalDeviceProtectedMemoryProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES;
+        PhysicalDeviceProvokingVertexPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT;
+        PhysicalDevicePushDescriptorProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES;
+        PhysicalDeviceRayTracingInvocationReorderPropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT;
+        PhysicalDeviceRayTracingPipelinePropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
+        PhysicalDeviceRobustness2PropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR;
+        PhysicalDeviceSampleLocationsPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT;
+        PhysicalDeviceSamplerFilterMinmaxProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
+        PhysicalDeviceShaderAbortPropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES_KHR;
+        PhysicalDeviceShaderIntegerDotProductProperties.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
+        PhysicalDeviceShaderLongVectorPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT;
+        PhysicalDeviceShaderModuleIdentifierPropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT;
+        PhysicalDeviceShaderObjectPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT;
+        PhysicalDeviceShaderTileImagePropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT;
+        PhysicalDeviceSubgroupProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
+        PhysicalDeviceSubgroupSizeControlProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
+        PhysicalDeviceTexelBufferAlignmentProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
+        PhysicalDeviceTimelineSemaphoreProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
+        PhysicalDeviceTransformFeedbackPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
+        PhysicalDeviceVertexAttributeDivisorProperties.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES;
+        PhysicalDeviceVertexAttributeDivisorPropertiesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT;
+        PhysicalDeviceVulkan11Properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
+        PhysicalDeviceVulkan12Properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
+        PhysicalDeviceVulkan13Properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES;
+        PhysicalDeviceVulkan14Properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES;
+        std::vector<VkBaseOutStructure *> chain_members{};
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceAccelerationStructurePropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceBlendOperationAdvancedPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceComputeShaderDerivativesPropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceConservativeRasterizationPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceCooperativeMatrixPropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COPY_MEMORY_INDIRECT_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceCopyMemoryIndirectPropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceCustomBorderColorPropertiesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDepthStencilResolveProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDescriptorBufferPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_HEAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDescriptorHeapPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_HEAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDescriptorHeapTensorPropertiesARM));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDescriptorIndexingProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDiscardRectanglePropertiesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDriverProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDrmPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceExtendedDynamicState3PropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceExternalMemoryHostPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DEVICE_FAULT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFaultPropertiesKHR));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFloatControlsProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFragmentDensityMap2PropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFragmentDensityMapPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFragmentShaderBarycentricPropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFragmentShadingRatePropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceHostImageCopyProperties));
+        if ((inst.CheckExtensionEnabled(VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME) ||
+             inst.CheckExtensionEnabled(VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME) ||
+             inst.CheckExtensionEnabled(VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceIDProperties));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceInlineUniformBlockProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_7_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceLayeredApiPropertiesListKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LEGACY_VERTEX_ATTRIBUTES_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceLegacyVertexAttributesPropertiesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME) ||
+             gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceLineRasterizationProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_10_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance10PropertiesKHR));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_3_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance3Properties));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_4_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance4Properties));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_5_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance5Properties));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_6_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance6Properties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_7_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance7PropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_9_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance9PropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MAP_MEMORY_PLACED_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMapMemoryPlacedPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MEMORY_DECOMPRESSION_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMemoryDecompressionPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MESH_SHADER_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMeshShaderPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MULTI_DRAW_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMultiDrawPropertiesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MULTIVIEW_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMultiviewProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_NESTED_COMMAND_BUFFER_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceNestedCommandBufferPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_OPACITY_MICROMAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceOpacityMicromapPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PCI_BUS_INFO_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePCIBusInfoPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePerformanceQueryPropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PIPELINE_BINARY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePipelineBinaryPropertiesKHR));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePipelineRobustnessProperties));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_2_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePointClippingProperties));
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePortabilitySubsetPropertiesKHR));
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+        if (gpu.api_version == VK_API_VERSION_1_1 || show_promoted_structs)
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceProtectedMemoryProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceProvokingVertexPropertiesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePushDescriptorProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME))
+            chain_members.push_back(
+                reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceRayTracingInvocationReorderPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceRayTracingPipelinePropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_ROBUSTNESS_2_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceRobustness2PropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceSampleLocationsPropertiesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceSamplerFilterMinmaxProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_ABORT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderAbortPropertiesKHR));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderIntegerDotProductProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_LONG_VECTOR_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderLongVectorPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderModuleIdentifierPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_OBJECT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderObjectPropertiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_TILE_IMAGE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderTileImagePropertiesEXT));
+        if (gpu.api_version == VK_API_VERSION_1_1 || show_promoted_structs)
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceSubgroupProperties));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceSubgroupSizeControlProperties));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceTexelBufferAlignmentProperties));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceTimelineSemaphoreProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceTransformFeedbackPropertiesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVertexAttributeDivisorProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVertexAttributeDivisorPropertiesEXT));
+        if ((gpu.api_version >= VK_API_VERSION_1_2))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVulkan11Properties));
+        if ((gpu.api_version >= VK_API_VERSION_1_2))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVulkan12Properties));
+        if ((gpu.api_version >= VK_API_VERSION_1_3))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVulkan13Properties));
+        if ((gpu.api_version >= VK_API_VERSION_1_4))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVulkan14Properties));
+
+        if (!chain_members.empty()) {
+            for (size_t i = 0; i < chain_members.size() - 1; i++) {
+                chain_members[i]->pNext = chain_members[i + 1];
+            }
+            start_of_chain = chain_members[0];
+        }
+    }
+};
+void setup_phys_device_props2_chain(VkPhysicalDeviceProperties2 &start, std::unique_ptr<phys_device_props2_chain> &chain,
+                                    AppInstance &inst, AppGpu &gpu, bool show_promoted_structs) {
+    chain = std::unique_ptr<phys_device_props2_chain>(new phys_device_props2_chain());
+    chain->initialize_chain(inst, gpu, show_promoted_structs);
+    start.pNext = chain->start_of_chain;
+};
+
+void chain_iterator_phys_device_props2(Printer &p, AppInstance &inst, AppGpu &gpu, bool show_promoted_structs, const void *place) {
+    while (place) {
+        const VkBaseOutStructure *structure = (const VkBaseOutStructure *)place;
+        p.SetSubHeader();
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR) {
+            const VkPhysicalDeviceAccelerationStructurePropertiesKHR *props =
+                (const VkPhysicalDeviceAccelerationStructurePropertiesKHR *)structure;
+            const char *name = "VkPhysicalDeviceAccelerationStructurePropertiesKHR";
+            DumpVkPhysicalDeviceAccelerationStructurePropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT) {
+            const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *props =
+                (const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT";
+            DumpVkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR) {
+            const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR *props =
+                (const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR *)structure;
+            const char *name = "VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR";
+            DumpVkPhysicalDeviceComputeShaderDerivativesPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT) {
+            const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *props =
+                (const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceConservativeRasterizationPropertiesEXT";
+            DumpVkPhysicalDeviceConservativeRasterizationPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR) {
+            const VkPhysicalDeviceCooperativeMatrixPropertiesKHR *props =
+                (const VkPhysicalDeviceCooperativeMatrixPropertiesKHR *)structure;
+            const char *name = "VkPhysicalDeviceCooperativeMatrixPropertiesKHR";
+            DumpVkPhysicalDeviceCooperativeMatrixPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR) {
+            const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR *props =
+                (const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COPY_MEMORY_INDIRECT_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR"
+                                   : ("VkPhysicalDeviceCopyMemoryIndirectPropertiesNV");
+            DumpVkPhysicalDeviceCopyMemoryIndirectPropertiesKHR(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceCopyMemoryIndirectPropertiesNV") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceCopyMemoryIndirectPropertiesKHR(p, "VkPhysicalDeviceCopyMemoryIndirectPropertiesNV", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT) {
+            const VkPhysicalDeviceCustomBorderColorPropertiesEXT *props =
+                (const VkPhysicalDeviceCustomBorderColorPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceCustomBorderColorPropertiesEXT";
+            DumpVkPhysicalDeviceCustomBorderColorPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES) {
+            const VkPhysicalDeviceDepthStencilResolveProperties *props =
+                (const VkPhysicalDeviceDepthStencilResolveProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceDepthStencilResolveProperties"
+                                                                     : ("VkPhysicalDeviceDepthStencilResolvePropertiesKHR");
+            DumpVkPhysicalDeviceDepthStencilResolveProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceDepthStencilResolvePropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceDepthStencilResolveProperties(p, "VkPhysicalDeviceDepthStencilResolvePropertiesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT) {
+            const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *props =
+                (const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT";
+            DumpVkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT) {
+            const VkPhysicalDeviceDescriptorBufferPropertiesEXT *props =
+                (const VkPhysicalDeviceDescriptorBufferPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDescriptorBufferPropertiesEXT";
+            DumpVkPhysicalDeviceDescriptorBufferPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT) {
+            const VkPhysicalDeviceDescriptorHeapPropertiesEXT *props =
+                (const VkPhysicalDeviceDescriptorHeapPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDescriptorHeapPropertiesEXT";
+            DumpVkPhysicalDeviceDescriptorHeapPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM) {
+            const VkPhysicalDeviceDescriptorHeapTensorPropertiesARM *props =
+                (const VkPhysicalDeviceDescriptorHeapTensorPropertiesARM *)structure;
+            const char *name = "VkPhysicalDeviceDescriptorHeapTensorPropertiesARM";
+            DumpVkPhysicalDeviceDescriptorHeapTensorPropertiesARM(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES) {
+            const VkPhysicalDeviceDescriptorIndexingProperties *props =
+                (const VkPhysicalDeviceDescriptorIndexingProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceDescriptorIndexingProperties"
+                                                                     : ("VkPhysicalDeviceDescriptorIndexingPropertiesEXT");
+            DumpVkPhysicalDeviceDescriptorIndexingProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceDescriptorIndexingPropertiesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceDescriptorIndexingProperties(p, "VkPhysicalDeviceDescriptorIndexingPropertiesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT) {
+            const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *props =
+                (const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT";
+            DumpVkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT) {
+            const VkPhysicalDeviceDiscardRectanglePropertiesEXT *props =
+                (const VkPhysicalDeviceDiscardRectanglePropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDiscardRectanglePropertiesEXT";
+            DumpVkPhysicalDeviceDiscardRectanglePropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES) {
+            const VkPhysicalDeviceDriverProperties *props = (const VkPhysicalDeviceDriverProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceDriverProperties"
+                                                                     : ("VkPhysicalDeviceDriverPropertiesKHR");
+            DumpVkPhysicalDeviceDriverProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceDriverPropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceDriverProperties(p, "VkPhysicalDeviceDriverPropertiesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT) {
+            const VkPhysicalDeviceDrmPropertiesEXT *props = (const VkPhysicalDeviceDrmPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDrmPropertiesEXT";
+            DumpVkPhysicalDeviceDrmPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT) {
+            const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *props =
+                (const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceExtendedDynamicState3PropertiesEXT";
+            DumpVkPhysicalDeviceExtendedDynamicState3PropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT) {
+            const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *props =
+                (const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceExternalMemoryHostPropertiesEXT";
+            DumpVkPhysicalDeviceExternalMemoryHostPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_PROPERTIES_KHR) {
+            const VkPhysicalDeviceFaultPropertiesKHR *props = (const VkPhysicalDeviceFaultPropertiesKHR *)structure;
+            const char *name = "VkPhysicalDeviceFaultPropertiesKHR";
+            DumpVkPhysicalDeviceFaultPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES) {
+            const VkPhysicalDeviceFloatControlsProperties *props = (const VkPhysicalDeviceFloatControlsProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceFloatControlsProperties"
+                                                                     : ("VkPhysicalDeviceFloatControlsPropertiesKHR");
+            DumpVkPhysicalDeviceFloatControlsProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceFloatControlsPropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceFloatControlsProperties(p, "VkPhysicalDeviceFloatControlsPropertiesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT) {
+            const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *props =
+                (const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceFragmentDensityMap2PropertiesEXT";
+            DumpVkPhysicalDeviceFragmentDensityMap2PropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT) {
+            const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *props =
+                (const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT"
+                                   : ("VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM");
+            DumpVkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT(
+                    p, "VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT) {
+            const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *props =
+                (const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceFragmentDensityMapPropertiesEXT";
+            DumpVkPhysicalDeviceFragmentDensityMapPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR) {
+            const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *props =
+                (const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *)structure;
+            const char *name = "VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR";
+            DumpVkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR) {
+            const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *props =
+                (const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *)structure;
+            const char *name = "VkPhysicalDeviceFragmentShadingRatePropertiesKHR";
+            DumpVkPhysicalDeviceFragmentShadingRatePropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT) {
+            const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *props =
+                (const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT";
+            DumpVkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES) {
+            const VkPhysicalDeviceHostImageCopyProperties *props = (const VkPhysicalDeviceHostImageCopyProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceHostImageCopyProperties"
+                                                                     : ("VkPhysicalDeviceHostImageCopyPropertiesEXT");
+            DumpVkPhysicalDeviceHostImageCopyProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceHostImageCopyPropertiesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceHostImageCopyProperties(p, "VkPhysicalDeviceHostImageCopyPropertiesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES) {
+            const VkPhysicalDeviceIDProperties *props = (const VkPhysicalDeviceIDProperties *)structure;
+            const char *name =
+                gpu.api_version >= VK_API_VERSION_1_1 ? "VkPhysicalDeviceIDProperties" : ("VkPhysicalDeviceIDPropertiesKHR");
+            DumpVkPhysicalDeviceIDProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceIDPropertiesKHR") != 0 &&
+                inst.CheckExtensionEnabled(VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceIDProperties(p, "VkPhysicalDeviceIDPropertiesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES) {
+            const VkPhysicalDeviceInlineUniformBlockProperties *props =
+                (const VkPhysicalDeviceInlineUniformBlockProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceInlineUniformBlockProperties"
+                                                                     : ("VkPhysicalDeviceInlineUniformBlockPropertiesEXT");
+            DumpVkPhysicalDeviceInlineUniformBlockProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceInlineUniformBlockPropertiesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceInlineUniformBlockProperties(p, "VkPhysicalDeviceInlineUniformBlockPropertiesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR) {
+            const VkPhysicalDeviceLayeredApiPropertiesListKHR *props =
+                (const VkPhysicalDeviceLayeredApiPropertiesListKHR *)structure;
+            const char *name = "VkPhysicalDeviceLayeredApiPropertiesListKHR";
+            DumpVkPhysicalDeviceLayeredApiPropertiesListKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT) {
+            const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT *props =
+                (const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT";
+            DumpVkPhysicalDeviceLegacyVertexAttributesPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES) {
+            const VkPhysicalDeviceLineRasterizationProperties *props =
+                (const VkPhysicalDeviceLineRasterizationProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4
+                                   ? "VkPhysicalDeviceLineRasterizationProperties"
+                                   : (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME)
+                                          ? "VkPhysicalDeviceLineRasterizationPropertiesKHR"
+                                          : ("VkPhysicalDeviceLineRasterizationPropertiesEXT"));
+            DumpVkPhysicalDeviceLineRasterizationProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceLineRasterizationPropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceLineRasterizationProperties(p, "VkPhysicalDeviceLineRasterizationPropertiesKHR", *props);
+            }
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceLineRasterizationPropertiesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceLineRasterizationProperties(p, "VkPhysicalDeviceLineRasterizationPropertiesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR) {
+            const VkPhysicalDeviceMaintenance10PropertiesKHR *props = (const VkPhysicalDeviceMaintenance10PropertiesKHR *)structure;
+            const char *name = "VkPhysicalDeviceMaintenance10PropertiesKHR";
+            DumpVkPhysicalDeviceMaintenance10PropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES) {
+            const VkPhysicalDeviceMaintenance3Properties *props = (const VkPhysicalDeviceMaintenance3Properties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_1 ? "VkPhysicalDeviceMaintenance3Properties"
+                                                                     : ("VkPhysicalDeviceMaintenance3PropertiesKHR");
+            DumpVkPhysicalDeviceMaintenance3Properties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMaintenance3PropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_3_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceMaintenance3Properties(p, "VkPhysicalDeviceMaintenance3PropertiesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES) {
+            const VkPhysicalDeviceMaintenance4Properties *props = (const VkPhysicalDeviceMaintenance4Properties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceMaintenance4Properties"
+                                                                     : ("VkPhysicalDeviceMaintenance4PropertiesKHR");
+            DumpVkPhysicalDeviceMaintenance4Properties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMaintenance4PropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_4_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceMaintenance4Properties(p, "VkPhysicalDeviceMaintenance4PropertiesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES) {
+            const VkPhysicalDeviceMaintenance5Properties *props = (const VkPhysicalDeviceMaintenance5Properties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceMaintenance5Properties"
+                                                                     : ("VkPhysicalDeviceMaintenance5PropertiesKHR");
+            DumpVkPhysicalDeviceMaintenance5Properties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMaintenance5PropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_5_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceMaintenance5Properties(p, "VkPhysicalDeviceMaintenance5PropertiesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES) {
+            const VkPhysicalDeviceMaintenance6Properties *props = (const VkPhysicalDeviceMaintenance6Properties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceMaintenance6Properties"
+                                                                     : ("VkPhysicalDeviceMaintenance6PropertiesKHR");
+            DumpVkPhysicalDeviceMaintenance6Properties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMaintenance6PropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_6_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceMaintenance6Properties(p, "VkPhysicalDeviceMaintenance6PropertiesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR) {
+            const VkPhysicalDeviceMaintenance7PropertiesKHR *props = (const VkPhysicalDeviceMaintenance7PropertiesKHR *)structure;
+            const char *name = "VkPhysicalDeviceMaintenance7PropertiesKHR";
+            DumpVkPhysicalDeviceMaintenance7PropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR) {
+            const VkPhysicalDeviceMaintenance9PropertiesKHR *props = (const VkPhysicalDeviceMaintenance9PropertiesKHR *)structure;
+            const char *name = "VkPhysicalDeviceMaintenance9PropertiesKHR";
+            DumpVkPhysicalDeviceMaintenance9PropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT) {
+            const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *props =
+                (const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceMapMemoryPlacedPropertiesEXT";
+            DumpVkPhysicalDeviceMapMemoryPlacedPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT) {
+            const VkPhysicalDeviceMemoryDecompressionPropertiesEXT *props =
+                (const VkPhysicalDeviceMemoryDecompressionPropertiesEXT *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MEMORY_DECOMPRESSION_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceMemoryDecompressionPropertiesEXT"
+                                   : ("VkPhysicalDeviceMemoryDecompressionPropertiesNV");
+            DumpVkPhysicalDeviceMemoryDecompressionPropertiesEXT(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMemoryDecompressionPropertiesNV") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceMemoryDecompressionPropertiesEXT(p, "VkPhysicalDeviceMemoryDecompressionPropertiesNV", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT) {
+            const VkPhysicalDeviceMeshShaderPropertiesEXT *props = (const VkPhysicalDeviceMeshShaderPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceMeshShaderPropertiesEXT";
+            DumpVkPhysicalDeviceMeshShaderPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT) {
+            const VkPhysicalDeviceMultiDrawPropertiesEXT *props = (const VkPhysicalDeviceMultiDrawPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceMultiDrawPropertiesEXT";
+            DumpVkPhysicalDeviceMultiDrawPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES) {
+            const VkPhysicalDeviceMultiviewProperties *props = (const VkPhysicalDeviceMultiviewProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_1 ? "VkPhysicalDeviceMultiviewProperties"
+                                                                     : ("VkPhysicalDeviceMultiviewPropertiesKHR");
+            DumpVkPhysicalDeviceMultiviewProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMultiviewPropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MULTIVIEW_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceMultiviewProperties(p, "VkPhysicalDeviceMultiviewPropertiesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT) {
+            const VkPhysicalDeviceNestedCommandBufferPropertiesEXT *props =
+                (const VkPhysicalDeviceNestedCommandBufferPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceNestedCommandBufferPropertiesEXT";
+            DumpVkPhysicalDeviceNestedCommandBufferPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT) {
+            const VkPhysicalDeviceOpacityMicromapPropertiesEXT *props =
+                (const VkPhysicalDeviceOpacityMicromapPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceOpacityMicromapPropertiesEXT";
+            DumpVkPhysicalDeviceOpacityMicromapPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT) {
+            const VkPhysicalDevicePCIBusInfoPropertiesEXT *props = (const VkPhysicalDevicePCIBusInfoPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDevicePCIBusInfoPropertiesEXT";
+            DumpVkPhysicalDevicePCIBusInfoPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR) {
+            const VkPhysicalDevicePerformanceQueryPropertiesKHR *props =
+                (const VkPhysicalDevicePerformanceQueryPropertiesKHR *)structure;
+            const char *name = "VkPhysicalDevicePerformanceQueryPropertiesKHR";
+            DumpVkPhysicalDevicePerformanceQueryPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR) {
+            const VkPhysicalDevicePipelineBinaryPropertiesKHR *props =
+                (const VkPhysicalDevicePipelineBinaryPropertiesKHR *)structure;
+            const char *name = "VkPhysicalDevicePipelineBinaryPropertiesKHR";
+            DumpVkPhysicalDevicePipelineBinaryPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES) {
+            const VkPhysicalDevicePipelineRobustnessProperties *props =
+                (const VkPhysicalDevicePipelineRobustnessProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDevicePipelineRobustnessProperties"
+                                                                     : ("VkPhysicalDevicePipelineRobustnessPropertiesEXT");
+            DumpVkPhysicalDevicePipelineRobustnessProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePipelineRobustnessPropertiesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDevicePipelineRobustnessProperties(p, "VkPhysicalDevicePipelineRobustnessPropertiesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES) {
+            const VkPhysicalDevicePointClippingProperties *props = (const VkPhysicalDevicePointClippingProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_1 ? "VkPhysicalDevicePointClippingProperties"
+                                                                     : ("VkPhysicalDevicePointClippingPropertiesKHR");
+            DumpVkPhysicalDevicePointClippingProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePointClippingPropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_2_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDevicePointClippingProperties(p, "VkPhysicalDevicePointClippingPropertiesKHR", *props);
+            }
+            p.AddNewline();
+        }
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR &&
+            p.Type() != OutputType::json) {
+            const VkPhysicalDevicePortabilitySubsetPropertiesKHR *props =
+                (const VkPhysicalDevicePortabilitySubsetPropertiesKHR *)structure;
+            const char *name = "VkPhysicalDevicePortabilitySubsetPropertiesKHR";
+            DumpVkPhysicalDevicePortabilitySubsetPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES) {
+            const VkPhysicalDeviceProtectedMemoryProperties *props = (const VkPhysicalDeviceProtectedMemoryProperties *)structure;
+            const char *name = "VkPhysicalDeviceProtectedMemoryProperties";
+            DumpVkPhysicalDeviceProtectedMemoryProperties(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT) {
+            const VkPhysicalDeviceProvokingVertexPropertiesEXT *props =
+                (const VkPhysicalDeviceProvokingVertexPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceProvokingVertexPropertiesEXT";
+            DumpVkPhysicalDeviceProvokingVertexPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES) {
+            const VkPhysicalDevicePushDescriptorProperties *props = (const VkPhysicalDevicePushDescriptorProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDevicePushDescriptorProperties"
+                                                                     : ("VkPhysicalDevicePushDescriptorPropertiesKHR");
+            DumpVkPhysicalDevicePushDescriptorProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePushDescriptorPropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDevicePushDescriptorProperties(p, "VkPhysicalDevicePushDescriptorPropertiesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT) {
+            const VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT *props =
+                (const VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT";
+            DumpVkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR) {
+            const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *props =
+                (const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *)structure;
+            const char *name = "VkPhysicalDeviceRayTracingPipelinePropertiesKHR";
+            DumpVkPhysicalDeviceRayTracingPipelinePropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR) {
+            const VkPhysicalDeviceRobustness2PropertiesKHR *props = (const VkPhysicalDeviceRobustness2PropertiesKHR *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_ROBUSTNESS_2_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceRobustness2PropertiesKHR"
+                                   : ("VkPhysicalDeviceRobustness2PropertiesEXT");
+            DumpVkPhysicalDeviceRobustness2PropertiesKHR(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceRobustness2PropertiesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceRobustness2PropertiesKHR(p, "VkPhysicalDeviceRobustness2PropertiesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT) {
+            const VkPhysicalDeviceSampleLocationsPropertiesEXT *props =
+                (const VkPhysicalDeviceSampleLocationsPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceSampleLocationsPropertiesEXT";
+            DumpVkPhysicalDeviceSampleLocationsPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES) {
+            const VkPhysicalDeviceSamplerFilterMinmaxProperties *props =
+                (const VkPhysicalDeviceSamplerFilterMinmaxProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceSamplerFilterMinmaxProperties"
+                                                                     : ("VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT");
+            DumpVkPhysicalDeviceSamplerFilterMinmaxProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceSamplerFilterMinmaxProperties(p, "VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES_KHR) {
+            const VkPhysicalDeviceShaderAbortPropertiesKHR *props = (const VkPhysicalDeviceShaderAbortPropertiesKHR *)structure;
+            const char *name = "VkPhysicalDeviceShaderAbortPropertiesKHR";
+            DumpVkPhysicalDeviceShaderAbortPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES) {
+            const VkPhysicalDeviceShaderIntegerDotProductProperties *props =
+                (const VkPhysicalDeviceShaderIntegerDotProductProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceShaderIntegerDotProductProperties"
+                                                                     : ("VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR");
+            DumpVkPhysicalDeviceShaderIntegerDotProductProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceShaderIntegerDotProductProperties(p, "VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR",
+                                                                      *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT) {
+            const VkPhysicalDeviceShaderLongVectorPropertiesEXT *props =
+                (const VkPhysicalDeviceShaderLongVectorPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderLongVectorPropertiesEXT";
+            DumpVkPhysicalDeviceShaderLongVectorPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT) {
+            const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *props =
+                (const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT";
+            DumpVkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT) {
+            const VkPhysicalDeviceShaderObjectPropertiesEXT *props = (const VkPhysicalDeviceShaderObjectPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderObjectPropertiesEXT";
+            DumpVkPhysicalDeviceShaderObjectPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT) {
+            const VkPhysicalDeviceShaderTileImagePropertiesEXT *props =
+                (const VkPhysicalDeviceShaderTileImagePropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderTileImagePropertiesEXT";
+            DumpVkPhysicalDeviceShaderTileImagePropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES) {
+            const VkPhysicalDeviceSubgroupProperties *props = (const VkPhysicalDeviceSubgroupProperties *)structure;
+            const char *name = "VkPhysicalDeviceSubgroupProperties";
+            DumpVkPhysicalDeviceSubgroupProperties(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES) {
+            const VkPhysicalDeviceSubgroupSizeControlProperties *props =
+                (const VkPhysicalDeviceSubgroupSizeControlProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceSubgroupSizeControlProperties"
+                                                                     : ("VkPhysicalDeviceSubgroupSizeControlPropertiesEXT");
+            DumpVkPhysicalDeviceSubgroupSizeControlProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceSubgroupSizeControlPropertiesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceSubgroupSizeControlProperties(p, "VkPhysicalDeviceSubgroupSizeControlPropertiesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES) {
+            const VkPhysicalDeviceTexelBufferAlignmentProperties *props =
+                (const VkPhysicalDeviceTexelBufferAlignmentProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceTexelBufferAlignmentProperties"
+                                                                     : ("VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT");
+            DumpVkPhysicalDeviceTexelBufferAlignmentProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceTexelBufferAlignmentProperties(p, "VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES) {
+            const VkPhysicalDeviceTimelineSemaphoreProperties *props =
+                (const VkPhysicalDeviceTimelineSemaphoreProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceTimelineSemaphoreProperties"
+                                                                     : ("VkPhysicalDeviceTimelineSemaphorePropertiesKHR");
+            DumpVkPhysicalDeviceTimelineSemaphoreProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceTimelineSemaphorePropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceTimelineSemaphoreProperties(p, "VkPhysicalDeviceTimelineSemaphorePropertiesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT) {
+            const VkPhysicalDeviceTransformFeedbackPropertiesEXT *props =
+                (const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceTransformFeedbackPropertiesEXT";
+            DumpVkPhysicalDeviceTransformFeedbackPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES) {
+            const VkPhysicalDeviceVertexAttributeDivisorProperties *props =
+                (const VkPhysicalDeviceVertexAttributeDivisorProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceVertexAttributeDivisorProperties"
+                                                                     : ("VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR");
+            DumpVkPhysicalDeviceVertexAttributeDivisorProperties(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceVertexAttributeDivisorProperties(p, "VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR",
+                                                                     *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT) {
+            const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *props =
+                (const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)structure;
+            const char *name = "VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT";
+            DumpVkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES) {
+            const VkPhysicalDeviceVulkan11Properties *props = (const VkPhysicalDeviceVulkan11Properties *)structure;
+            const char *name = "VkPhysicalDeviceVulkan11Properties";
+            DumpVkPhysicalDeviceVulkan11Properties(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES) {
+            const VkPhysicalDeviceVulkan12Properties *props = (const VkPhysicalDeviceVulkan12Properties *)structure;
+            const char *name = "VkPhysicalDeviceVulkan12Properties";
+            DumpVkPhysicalDeviceVulkan12Properties(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES) {
+            const VkPhysicalDeviceVulkan13Properties *props = (const VkPhysicalDeviceVulkan13Properties *)structure;
+            const char *name = "VkPhysicalDeviceVulkan13Properties";
+            DumpVkPhysicalDeviceVulkan13Properties(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES) {
+            const VkPhysicalDeviceVulkan14Properties *props = (const VkPhysicalDeviceVulkan14Properties *)structure;
+            const char *name = "VkPhysicalDeviceVulkan14Properties";
+            DumpVkPhysicalDeviceVulkan14Properties(p, name, *props);
+            p.AddNewline();
+        }
+        place = structure->pNext;
+    }
+}
+
+bool prepare_phys_device_props2_twocall_chain_vectors(std::unique_ptr<phys_device_props2_chain> &chain) {
+    (void)chain;
+    chain->VkPhysicalDeviceHostImageCopyProperties_pCopySrcLayouts.resize(
+        chain->PhysicalDeviceHostImageCopyProperties.copySrcLayoutCount);
+    chain->PhysicalDeviceHostImageCopyProperties.pCopySrcLayouts =
+        chain->VkPhysicalDeviceHostImageCopyProperties_pCopySrcLayouts.data();
+    chain->VkPhysicalDeviceHostImageCopyProperties_pCopyDstLayouts.resize(
+        chain->PhysicalDeviceHostImageCopyProperties.copyDstLayoutCount);
+    chain->PhysicalDeviceHostImageCopyProperties.pCopyDstLayouts =
+        chain->VkPhysicalDeviceHostImageCopyProperties_pCopyDstLayouts.data();
+    chain->VkPhysicalDeviceLayeredApiPropertiesListKHR_pLayeredApis.resize(
+        chain->PhysicalDeviceLayeredApiPropertiesListKHR.layeredApiCount);
+    chain->PhysicalDeviceLayeredApiPropertiesListKHR.pLayeredApis =
+        chain->VkPhysicalDeviceLayeredApiPropertiesListKHR_pLayeredApis.data();
+    chain->VkPhysicalDeviceVulkan14Properties_pCopySrcLayouts.resize(chain->PhysicalDeviceVulkan14Properties.copySrcLayoutCount);
+    chain->PhysicalDeviceVulkan14Properties.pCopySrcLayouts = chain->VkPhysicalDeviceVulkan14Properties_pCopySrcLayouts.data();
+    chain->VkPhysicalDeviceVulkan14Properties_pCopyDstLayouts.resize(chain->PhysicalDeviceVulkan14Properties.copyDstLayoutCount);
+    chain->PhysicalDeviceVulkan14Properties.pCopyDstLayouts = chain->VkPhysicalDeviceVulkan14Properties_pCopyDstLayouts.data();
+    return true;
+}
+struct phys_device_mem_props2_chain {
+    phys_device_mem_props2_chain() = default;
+    phys_device_mem_props2_chain(const phys_device_mem_props2_chain &) = delete;
+    phys_device_mem_props2_chain &operator=(const phys_device_mem_props2_chain &) = delete;
+    phys_device_mem_props2_chain(phys_device_mem_props2_chain &&) = delete;
+    phys_device_mem_props2_chain &operator=(phys_device_mem_props2_chain &&) = delete;
+    void *start_of_chain = nullptr;
+    VkPhysicalDeviceMemoryBudgetPropertiesEXT PhysicalDeviceMemoryBudgetPropertiesEXT{};
+    void initialize_chain(AppGpu &gpu) noexcept {
+        PhysicalDeviceMemoryBudgetPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
+        std::vector<VkBaseOutStructure *> chain_members{};
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MEMORY_BUDGET_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMemoryBudgetPropertiesEXT));
+
+        if (!chain_members.empty()) {
+            for (size_t i = 0; i < chain_members.size() - 1; i++) {
+                chain_members[i]->pNext = chain_members[i + 1];
+            }
+            start_of_chain = chain_members[0];
+        }
+    }
+};
+void setup_phys_device_mem_props2_chain(VkPhysicalDeviceMemoryProperties2 &start,
+                                        std::unique_ptr<phys_device_mem_props2_chain> &chain, AppGpu &gpu) {
+    chain = std::unique_ptr<phys_device_mem_props2_chain>(new phys_device_mem_props2_chain());
+    chain->initialize_chain(gpu);
+    start.pNext = chain->start_of_chain;
+};
+
+bool prepare_phys_device_mem_props2_twocall_chain_vectors(std::unique_ptr<phys_device_mem_props2_chain> &chain) {
+    (void)chain;
+    return false;
+}
+struct phys_device_features2_chain {
+    phys_device_features2_chain() = default;
+    phys_device_features2_chain(const phys_device_features2_chain &) = delete;
+    phys_device_features2_chain &operator=(const phys_device_features2_chain &) = delete;
+    phys_device_features2_chain(phys_device_features2_chain &&) = delete;
+    phys_device_features2_chain &operator=(phys_device_features2_chain &&) = delete;
+    void *start_of_chain = nullptr;
+    VkPhysicalDevice16BitStorageFeatures PhysicalDevice16BitStorageFeatures{};
+    VkPhysicalDevice4444FormatsFeaturesEXT PhysicalDevice4444FormatsFeaturesEXT{};
+    VkPhysicalDevice8BitStorageFeatures PhysicalDevice8BitStorageFeatures{};
+    VkPhysicalDeviceASTCDecodeFeaturesEXT PhysicalDeviceASTCDecodeFeaturesEXT{};
+    VkPhysicalDeviceAccelerationStructureFeaturesKHR PhysicalDeviceAccelerationStructureFeaturesKHR{};
+    VkPhysicalDeviceAddressBindingReportFeaturesEXT PhysicalDeviceAddressBindingReportFeaturesEXT{};
+    VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT{};
+    VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT{};
+    VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT PhysicalDeviceBlendOperationAdvancedFeaturesEXT{};
+    VkPhysicalDeviceBorderColorSwizzleFeaturesEXT PhysicalDeviceBorderColorSwizzleFeaturesEXT{};
+    VkPhysicalDeviceBufferDeviceAddressFeatures PhysicalDeviceBufferDeviceAddressFeatures{};
+    VkPhysicalDeviceBufferDeviceAddressFeaturesEXT PhysicalDeviceBufferDeviceAddressFeaturesEXT{};
+    VkPhysicalDeviceColorWriteEnableFeaturesEXT PhysicalDeviceColorWriteEnableFeaturesEXT{};
+    VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR PhysicalDeviceComputeShaderDerivativesFeaturesKHR{};
+    VkPhysicalDeviceConditionalRenderingFeaturesEXT PhysicalDeviceConditionalRenderingFeaturesEXT{};
+    VkPhysicalDeviceCooperativeMatrixFeaturesKHR PhysicalDeviceCooperativeMatrixFeaturesKHR{};
+    VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR PhysicalDeviceCopyMemoryIndirectFeaturesKHR{};
+    VkPhysicalDeviceCustomBorderColorFeaturesEXT PhysicalDeviceCustomBorderColorFeaturesEXT{};
+    VkPhysicalDeviceCustomResolveFeaturesEXT PhysicalDeviceCustomResolveFeaturesEXT{};
+    VkPhysicalDeviceDepthBiasControlFeaturesEXT PhysicalDeviceDepthBiasControlFeaturesEXT{};
+    VkPhysicalDeviceDepthClampControlFeaturesEXT PhysicalDeviceDepthClampControlFeaturesEXT{};
+    VkPhysicalDeviceDepthClampZeroOneFeaturesKHR PhysicalDeviceDepthClampZeroOneFeaturesKHR{};
+    VkPhysicalDeviceDepthClipControlFeaturesEXT PhysicalDeviceDepthClipControlFeaturesEXT{};
+    VkPhysicalDeviceDepthClipEnableFeaturesEXT PhysicalDeviceDepthClipEnableFeaturesEXT{};
+    VkPhysicalDeviceDescriptorBufferFeaturesEXT PhysicalDeviceDescriptorBufferFeaturesEXT{};
+    VkPhysicalDeviceDescriptorHeapFeaturesEXT PhysicalDeviceDescriptorHeapFeaturesEXT{};
+    VkPhysicalDeviceDescriptorIndexingFeatures PhysicalDeviceDescriptorIndexingFeatures{};
+    VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR PhysicalDeviceDeviceAddressCommandsFeaturesKHR{};
+    VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT{};
+    VkPhysicalDeviceDeviceMemoryReportFeaturesEXT PhysicalDeviceDeviceMemoryReportFeaturesEXT{};
+    VkPhysicalDeviceDynamicRenderingFeatures PhysicalDeviceDynamicRenderingFeatures{};
+    VkPhysicalDeviceDynamicRenderingLocalReadFeatures PhysicalDeviceDynamicRenderingLocalReadFeatures{};
+    VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT{};
+    VkPhysicalDeviceExtendedDynamicState2FeaturesEXT PhysicalDeviceExtendedDynamicState2FeaturesEXT{};
+    VkPhysicalDeviceExtendedDynamicState3FeaturesEXT PhysicalDeviceExtendedDynamicState3FeaturesEXT{};
+    VkPhysicalDeviceExtendedDynamicStateFeaturesEXT PhysicalDeviceExtendedDynamicStateFeaturesEXT{};
+    VkPhysicalDeviceFaultFeaturesEXT PhysicalDeviceFaultFeaturesEXT{};
+    VkPhysicalDeviceFaultFeaturesKHR PhysicalDeviceFaultFeaturesKHR{};
+    VkPhysicalDeviceFragmentDensityMap2FeaturesEXT PhysicalDeviceFragmentDensityMap2FeaturesEXT{};
+    VkPhysicalDeviceFragmentDensityMapFeaturesEXT PhysicalDeviceFragmentDensityMapFeaturesEXT{};
+    VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT{};
+    VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR PhysicalDeviceFragmentShaderBarycentricFeaturesKHR{};
+    VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT PhysicalDeviceFragmentShaderInterlockFeaturesEXT{};
+    VkPhysicalDeviceFragmentShadingRateFeaturesKHR PhysicalDeviceFragmentShadingRateFeaturesKHR{};
+    VkPhysicalDeviceFrameBoundaryFeaturesEXT PhysicalDeviceFrameBoundaryFeaturesEXT{};
+    VkPhysicalDeviceGlobalPriorityQueryFeatures PhysicalDeviceGlobalPriorityQueryFeatures{};
+    VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT{};
+    VkPhysicalDeviceHostImageCopyFeatures PhysicalDeviceHostImageCopyFeatures{};
+    VkPhysicalDeviceHostQueryResetFeatures PhysicalDeviceHostQueryResetFeatures{};
+    VkPhysicalDeviceImage2DViewOf3DFeaturesEXT PhysicalDeviceImage2DViewOf3DFeaturesEXT{};
+    VkPhysicalDeviceImageCompressionControlFeaturesEXT PhysicalDeviceImageCompressionControlFeaturesEXT{};
+    VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT{};
+    VkPhysicalDeviceImageRobustnessFeatures PhysicalDeviceImageRobustnessFeatures{};
+    VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT PhysicalDeviceImageSlicedViewOf3DFeaturesEXT{};
+    VkPhysicalDeviceImageViewMinLodFeaturesEXT PhysicalDeviceImageViewMinLodFeaturesEXT{};
+    VkPhysicalDeviceImagelessFramebufferFeatures PhysicalDeviceImagelessFramebufferFeatures{};
+    VkPhysicalDeviceIndexTypeUint8Features PhysicalDeviceIndexTypeUint8Features{};
+    VkPhysicalDeviceInlineUniformBlockFeatures PhysicalDeviceInlineUniformBlockFeatures{};
+    VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR{};
+    VkPhysicalDeviceLegacyDitheringFeaturesEXT PhysicalDeviceLegacyDitheringFeaturesEXT{};
+    VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT PhysicalDeviceLegacyVertexAttributesFeaturesEXT{};
+    VkPhysicalDeviceLineRasterizationFeatures PhysicalDeviceLineRasterizationFeatures{};
+    VkPhysicalDeviceMaintenance10FeaturesKHR PhysicalDeviceMaintenance10FeaturesKHR{};
+    VkPhysicalDeviceMaintenance4Features PhysicalDeviceMaintenance4Features{};
+    VkPhysicalDeviceMaintenance5Features PhysicalDeviceMaintenance5Features{};
+    VkPhysicalDeviceMaintenance6Features PhysicalDeviceMaintenance6Features{};
+    VkPhysicalDeviceMaintenance7FeaturesKHR PhysicalDeviceMaintenance7FeaturesKHR{};
+    VkPhysicalDeviceMaintenance8FeaturesKHR PhysicalDeviceMaintenance8FeaturesKHR{};
+    VkPhysicalDeviceMaintenance9FeaturesKHR PhysicalDeviceMaintenance9FeaturesKHR{};
+    VkPhysicalDeviceMapMemoryPlacedFeaturesEXT PhysicalDeviceMapMemoryPlacedFeaturesEXT{};
+    VkPhysicalDeviceMemoryDecompressionFeaturesEXT PhysicalDeviceMemoryDecompressionFeaturesEXT{};
+    VkPhysicalDeviceMemoryPriorityFeaturesEXT PhysicalDeviceMemoryPriorityFeaturesEXT{};
+    VkPhysicalDeviceMeshShaderFeaturesEXT PhysicalDeviceMeshShaderFeaturesEXT{};
+    VkPhysicalDeviceMultiDrawFeaturesEXT PhysicalDeviceMultiDrawFeaturesEXT{};
+    VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT{};
+    VkPhysicalDeviceMultiviewFeatures PhysicalDeviceMultiviewFeatures{};
+    VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT PhysicalDeviceMutableDescriptorTypeFeaturesEXT{};
+    VkPhysicalDeviceNestedCommandBufferFeaturesEXT PhysicalDeviceNestedCommandBufferFeaturesEXT{};
+    VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT PhysicalDeviceNonSeamlessCubeMapFeaturesEXT{};
+    VkPhysicalDeviceOpacityMicromapFeaturesEXT PhysicalDeviceOpacityMicromapFeaturesEXT{};
+    VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT{};
+    VkPhysicalDevicePerformanceQueryFeaturesKHR PhysicalDevicePerformanceQueryFeaturesKHR{};
+    VkPhysicalDevicePipelineBinaryFeaturesKHR PhysicalDevicePipelineBinaryFeaturesKHR{};
+    VkPhysicalDevicePipelineCreationCacheControlFeatures PhysicalDevicePipelineCreationCacheControlFeatures{};
+    VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR PhysicalDevicePipelineExecutablePropertiesFeaturesKHR{};
+    VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT{};
+    VkPhysicalDevicePipelinePropertiesFeaturesEXT PhysicalDevicePipelinePropertiesFeaturesEXT{};
+    VkPhysicalDevicePipelineProtectedAccessFeatures PhysicalDevicePipelineProtectedAccessFeatures{};
+    VkPhysicalDevicePipelineRobustnessFeatures PhysicalDevicePipelineRobustnessFeatures{};
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    VkPhysicalDevicePortabilitySubsetFeaturesKHR PhysicalDevicePortabilitySubsetFeaturesKHR{};
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+    VkPhysicalDevicePresentId2FeaturesKHR PhysicalDevicePresentId2FeaturesKHR{};
+    VkPhysicalDevicePresentIdFeaturesKHR PhysicalDevicePresentIdFeaturesKHR{};
+    VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR{};
+    VkPhysicalDevicePresentTimingFeaturesEXT PhysicalDevicePresentTimingFeaturesEXT{};
+    VkPhysicalDevicePresentWait2FeaturesKHR PhysicalDevicePresentWait2FeaturesKHR{};
+    VkPhysicalDevicePresentWaitFeaturesKHR PhysicalDevicePresentWaitFeaturesKHR{};
+    VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT{};
+    VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT{};
+    VkPhysicalDevicePrivateDataFeatures PhysicalDevicePrivateDataFeatures{};
+    VkPhysicalDeviceProtectedMemoryFeatures PhysicalDeviceProtectedMemoryFeatures{};
+    VkPhysicalDeviceProvokingVertexFeaturesEXT PhysicalDeviceProvokingVertexFeaturesEXT{};
+    VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT PhysicalDeviceRGBA10X6FormatsFeaturesEXT{};
+    VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT{};
+    VkPhysicalDeviceRayQueryFeaturesKHR PhysicalDeviceRayQueryFeaturesKHR{};
+    VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT PhysicalDeviceRayTracingInvocationReorderFeaturesEXT{};
+    VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR PhysicalDeviceRayTracingMaintenance1FeaturesKHR{};
+    VkPhysicalDeviceRayTracingPipelineFeaturesKHR PhysicalDeviceRayTracingPipelineFeaturesKHR{};
+    VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR PhysicalDeviceRayTracingPositionFetchFeaturesKHR{};
+    VkPhysicalDeviceRobustness2FeaturesKHR PhysicalDeviceRobustness2FeaturesKHR{};
+    VkPhysicalDeviceSamplerYcbcrConversionFeatures PhysicalDeviceSamplerYcbcrConversionFeatures{};
+    VkPhysicalDeviceScalarBlockLayoutFeatures PhysicalDeviceScalarBlockLayoutFeatures{};
+    VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures PhysicalDeviceSeparateDepthStencilLayoutsFeatures{};
+    VkPhysicalDeviceShader64BitIndexingFeaturesEXT PhysicalDeviceShader64BitIndexingFeaturesEXT{};
+    VkPhysicalDeviceShaderAbortFeaturesKHR PhysicalDeviceShaderAbortFeaturesKHR{};
+    VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT PhysicalDeviceShaderAtomicFloat2FeaturesEXT{};
+    VkPhysicalDeviceShaderAtomicFloatFeaturesEXT PhysicalDeviceShaderAtomicFloatFeaturesEXT{};
+    VkPhysicalDeviceShaderAtomicInt64Features PhysicalDeviceShaderAtomicInt64Features{};
+    VkPhysicalDeviceShaderBfloat16FeaturesKHR PhysicalDeviceShaderBfloat16FeaturesKHR{};
+    VkPhysicalDeviceShaderClockFeaturesKHR PhysicalDeviceShaderClockFeaturesKHR{};
+    VkPhysicalDeviceShaderConstantDataFeaturesKHR PhysicalDeviceShaderConstantDataFeaturesKHR{};
+    VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures PhysicalDeviceShaderDemoteToHelperInvocationFeatures{};
+    VkPhysicalDeviceShaderDrawParametersFeatures PhysicalDeviceShaderDrawParametersFeatures{};
+    VkPhysicalDeviceShaderExpectAssumeFeatures PhysicalDeviceShaderExpectAssumeFeatures{};
+    VkPhysicalDeviceShaderFloat16Int8Features PhysicalDeviceShaderFloat16Int8Features{};
+    VkPhysicalDeviceShaderFloat8FeaturesEXT PhysicalDeviceShaderFloat8FeaturesEXT{};
+    VkPhysicalDeviceShaderFloatControls2Features PhysicalDeviceShaderFloatControls2Features{};
+    VkPhysicalDeviceShaderFmaFeaturesKHR PhysicalDeviceShaderFmaFeaturesKHR{};
+    VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT PhysicalDeviceShaderImageAtomicInt64FeaturesEXT{};
+    VkPhysicalDeviceShaderIntegerDotProductFeatures PhysicalDeviceShaderIntegerDotProductFeatures{};
+    char VkPhysicalDeviceShaderIntegerDotProductFeatures_padding[64];
+    VkPhysicalDeviceShaderLongVectorFeaturesEXT PhysicalDeviceShaderLongVectorFeaturesEXT{};
+    VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR{};
+    VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT PhysicalDeviceShaderModuleIdentifierFeaturesEXT{};
+    VkPhysicalDeviceShaderObjectFeaturesEXT PhysicalDeviceShaderObjectFeaturesEXT{};
+    VkPhysicalDeviceShaderQuadControlFeaturesKHR PhysicalDeviceShaderQuadControlFeaturesKHR{};
+    VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR{};
+    VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT PhysicalDeviceShaderReplicatedCompositesFeaturesEXT{};
+    VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures PhysicalDeviceShaderSubgroupExtendedTypesFeatures{};
+    VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT{};
+    VkPhysicalDeviceShaderSubgroupRotateFeatures PhysicalDeviceShaderSubgroupRotateFeatures{};
+    VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR{};
+    VkPhysicalDeviceShaderTerminateInvocationFeatures PhysicalDeviceShaderTerminateInvocationFeatures{};
+    VkPhysicalDeviceShaderTileImageFeaturesEXT PhysicalDeviceShaderTileImageFeaturesEXT{};
+    VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT{};
+    VkPhysicalDeviceShaderUntypedPointersFeaturesKHR PhysicalDeviceShaderUntypedPointersFeaturesKHR{};
+    VkPhysicalDeviceSubgroupSizeControlFeatures PhysicalDeviceSubgroupSizeControlFeatures{};
+    VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT PhysicalDeviceSubpassMergeFeedbackFeaturesEXT{};
+    VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR PhysicalDeviceSwapchainMaintenance1FeaturesKHR{};
+    VkPhysicalDeviceSynchronization2Features PhysicalDeviceSynchronization2Features{};
+    VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT PhysicalDeviceTexelBufferAlignmentFeaturesEXT{};
+    VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT PhysicalDeviceTextureCompressionASTC3DFeaturesEXT{};
+    VkPhysicalDeviceTextureCompressionASTCHDRFeatures PhysicalDeviceTextureCompressionASTCHDRFeatures{};
+    VkPhysicalDeviceTimelineSemaphoreFeatures PhysicalDeviceTimelineSemaphoreFeatures{};
+    VkPhysicalDeviceTransformFeedbackFeaturesEXT PhysicalDeviceTransformFeedbackFeaturesEXT{};
+    VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR PhysicalDeviceUnifiedImageLayoutsFeaturesKHR{};
+    VkPhysicalDeviceUniformBufferStandardLayoutFeatures PhysicalDeviceUniformBufferStandardLayoutFeatures{};
+    VkPhysicalDeviceVariablePointersFeatures PhysicalDeviceVariablePointersFeatures{};
+    VkPhysicalDeviceVertexAttributeDivisorFeatures PhysicalDeviceVertexAttributeDivisorFeatures{};
+    VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT PhysicalDeviceVertexAttributeRobustnessFeaturesEXT{};
+    VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT PhysicalDeviceVertexInputDynamicStateFeaturesEXT{};
+    VkPhysicalDeviceVideoDecodeVP9FeaturesKHR PhysicalDeviceVideoDecodeVP9FeaturesKHR{};
+    VkPhysicalDeviceVideoEncodeAV1FeaturesKHR PhysicalDeviceVideoEncodeAV1FeaturesKHR{};
+    VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR{};
+    VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR{};
+    VkPhysicalDeviceVideoMaintenance1FeaturesKHR PhysicalDeviceVideoMaintenance1FeaturesKHR{};
+    VkPhysicalDeviceVideoMaintenance2FeaturesKHR PhysicalDeviceVideoMaintenance2FeaturesKHR{};
+    VkPhysicalDeviceVulkan11Features PhysicalDeviceVulkan11Features{};
+    VkPhysicalDeviceVulkan12Features PhysicalDeviceVulkan12Features{};
+    VkPhysicalDeviceVulkan13Features PhysicalDeviceVulkan13Features{};
+    VkPhysicalDeviceVulkan14Features PhysicalDeviceVulkan14Features{};
+    VkPhysicalDeviceVulkanMemoryModelFeatures PhysicalDeviceVulkanMemoryModelFeatures{};
+    VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR{};
+    VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT{};
+    VkPhysicalDeviceYcbcrImageArraysFeaturesEXT PhysicalDeviceYcbcrImageArraysFeaturesEXT{};
+    VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT{};
+    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures{};
+    void initialize_chain(AppGpu &gpu, bool show_promoted_structs) noexcept {
+        PhysicalDevice16BitStorageFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
+        PhysicalDevice4444FormatsFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
+        PhysicalDevice8BitStorageFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
+        PhysicalDeviceASTCDecodeFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
+        PhysicalDeviceAccelerationStructureFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
+        PhysicalDeviceAddressBindingReportFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
+        PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
+        PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
+        PhysicalDeviceBlendOperationAdvancedFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
+        PhysicalDeviceBorderColorSwizzleFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
+        PhysicalDeviceBufferDeviceAddressFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
+        PhysicalDeviceBufferDeviceAddressFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
+        PhysicalDeviceColorWriteEnableFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
+        PhysicalDeviceComputeShaderDerivativesFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR;
+        PhysicalDeviceConditionalRenderingFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
+        PhysicalDeviceCooperativeMatrixFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR;
+        PhysicalDeviceCopyMemoryIndirectFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR;
+        PhysicalDeviceCustomBorderColorFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
+        PhysicalDeviceCustomResolveFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT;
+        PhysicalDeviceDepthBiasControlFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT;
+        PhysicalDeviceDepthClampControlFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT;
+        PhysicalDeviceDepthClampZeroOneFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR;
+        PhysicalDeviceDepthClipControlFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
+        PhysicalDeviceDepthClipEnableFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
+        PhysicalDeviceDescriptorBufferFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
+        PhysicalDeviceDescriptorHeapFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT;
+        PhysicalDeviceDescriptorIndexingFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
+        PhysicalDeviceDeviceAddressCommandsFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR;
+        PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT;
+        PhysicalDeviceDeviceMemoryReportFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT;
+        PhysicalDeviceDynamicRenderingFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
+        PhysicalDeviceDynamicRenderingLocalReadFeatures.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES;
+        PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT;
+        PhysicalDeviceExtendedDynamicState2FeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
+        PhysicalDeviceExtendedDynamicState3FeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
+        PhysicalDeviceExtendedDynamicStateFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
+        PhysicalDeviceFaultFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
+        PhysicalDeviceFaultFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR;
+        PhysicalDeviceFragmentDensityMap2FeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
+        PhysicalDeviceFragmentDensityMapFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
+        PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT;
+        PhysicalDeviceFragmentShaderBarycentricFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
+        PhysicalDeviceFragmentShaderInterlockFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
+        PhysicalDeviceFragmentShadingRateFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
+        PhysicalDeviceFrameBoundaryFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT;
+        PhysicalDeviceGlobalPriorityQueryFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES;
+        PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
+        PhysicalDeviceHostImageCopyFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES;
+        PhysicalDeviceHostQueryResetFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
+        PhysicalDeviceImage2DViewOf3DFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
+        PhysicalDeviceImageCompressionControlFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
+        PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
+        PhysicalDeviceImageRobustnessFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
+        PhysicalDeviceImageSlicedViewOf3DFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
+        PhysicalDeviceImageViewMinLodFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
+        PhysicalDeviceImagelessFramebufferFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
+        PhysicalDeviceIndexTypeUint8Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES;
+        PhysicalDeviceInlineUniformBlockFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
+        PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR;
+        PhysicalDeviceLegacyDitheringFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
+        PhysicalDeviceLegacyVertexAttributesFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT;
+        PhysicalDeviceLineRasterizationFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES;
+        PhysicalDeviceMaintenance10FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR;
+        PhysicalDeviceMaintenance4Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
+        PhysicalDeviceMaintenance5Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES;
+        PhysicalDeviceMaintenance6Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES;
+        PhysicalDeviceMaintenance7FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR;
+        PhysicalDeviceMaintenance8FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR;
+        PhysicalDeviceMaintenance9FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR;
+        PhysicalDeviceMapMemoryPlacedFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT;
+        PhysicalDeviceMemoryDecompressionFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT;
+        PhysicalDeviceMemoryPriorityFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
+        PhysicalDeviceMeshShaderFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
+        PhysicalDeviceMultiDrawFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
+        PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
+        PhysicalDeviceMultiviewFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
+        PhysicalDeviceMutableDescriptorTypeFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
+        PhysicalDeviceNestedCommandBufferFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT;
+        PhysicalDeviceNonSeamlessCubeMapFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
+        PhysicalDeviceOpacityMicromapFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
+        PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
+        PhysicalDevicePerformanceQueryFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
+        PhysicalDevicePipelineBinaryFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR;
+        PhysicalDevicePipelineCreationCacheControlFeatures.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
+        PhysicalDevicePipelineExecutablePropertiesFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
+        PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
+        PhysicalDevicePipelinePropertiesFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
+        PhysicalDevicePipelineProtectedAccessFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES;
+        PhysicalDevicePipelineRobustnessFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        PhysicalDevicePortabilitySubsetFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR;
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+        PhysicalDevicePresentId2FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR;
+        PhysicalDevicePresentIdFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
+        PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR;
+        PhysicalDevicePresentTimingFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT;
+        PhysicalDevicePresentWait2FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR;
+        PhysicalDevicePresentWaitFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
+        PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
+        PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
+        PhysicalDevicePrivateDataFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
+        PhysicalDeviceProtectedMemoryFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
+        PhysicalDeviceProvokingVertexFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
+        PhysicalDeviceRGBA10X6FormatsFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
+        PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
+        PhysicalDeviceRayQueryFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
+        PhysicalDeviceRayTracingInvocationReorderFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT;
+        PhysicalDeviceRayTracingMaintenance1FeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
+        PhysicalDeviceRayTracingPipelineFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
+        PhysicalDeviceRayTracingPositionFetchFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
+        PhysicalDeviceRobustness2FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR;
+        PhysicalDeviceSamplerYcbcrConversionFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
+        PhysicalDeviceScalarBlockLayoutFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
+        PhysicalDeviceSeparateDepthStencilLayoutsFeatures.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
+        PhysicalDeviceShader64BitIndexingFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT;
+        PhysicalDeviceShaderAbortFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR;
+        PhysicalDeviceShaderAtomicFloat2FeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
+        PhysicalDeviceShaderAtomicFloatFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
+        PhysicalDeviceShaderAtomicInt64Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
+        PhysicalDeviceShaderBfloat16FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR;
+        PhysicalDeviceShaderClockFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
+        PhysicalDeviceShaderConstantDataFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR;
+        PhysicalDeviceShaderDemoteToHelperInvocationFeatures.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
+        PhysicalDeviceShaderDrawParametersFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
+        PhysicalDeviceShaderExpectAssumeFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES;
+        PhysicalDeviceShaderFloat16Int8Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
+        PhysicalDeviceShaderFloat8FeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT;
+        PhysicalDeviceShaderFloatControls2Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES;
+        PhysicalDeviceShaderFmaFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR;
+        PhysicalDeviceShaderImageAtomicInt64FeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
+        PhysicalDeviceShaderIntegerDotProductFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
+        PhysicalDeviceShaderLongVectorFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT;
+        PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR;
+        PhysicalDeviceShaderModuleIdentifierFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
+        PhysicalDeviceShaderObjectFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
+        PhysicalDeviceShaderQuadControlFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR;
+        PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR;
+        PhysicalDeviceShaderReplicatedCompositesFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT;
+        PhysicalDeviceShaderSubgroupExtendedTypesFeatures.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
+        PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT;
+        PhysicalDeviceShaderSubgroupRotateFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES;
+        PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
+        PhysicalDeviceShaderTerminateInvocationFeatures.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
+        PhysicalDeviceShaderTileImageFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT;
+        PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT;
+        PhysicalDeviceShaderUntypedPointersFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR;
+        PhysicalDeviceSubgroupSizeControlFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
+        PhysicalDeviceSubpassMergeFeedbackFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
+        PhysicalDeviceSwapchainMaintenance1FeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR;
+        PhysicalDeviceSynchronization2Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
+        PhysicalDeviceTexelBufferAlignmentFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
+        PhysicalDeviceTextureCompressionASTC3DFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT;
+        PhysicalDeviceTextureCompressionASTCHDRFeatures.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
+        PhysicalDeviceTimelineSemaphoreFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
+        PhysicalDeviceTransformFeedbackFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
+        PhysicalDeviceUnifiedImageLayoutsFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR;
+        PhysicalDeviceUniformBufferStandardLayoutFeatures.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
+        PhysicalDeviceVariablePointersFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
+        PhysicalDeviceVertexAttributeDivisorFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES;
+        PhysicalDeviceVertexAttributeRobustnessFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT;
+        PhysicalDeviceVertexInputDynamicStateFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
+        PhysicalDeviceVideoDecodeVP9FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR;
+        PhysicalDeviceVideoEncodeAV1FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR;
+        PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR;
+        PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR;
+        PhysicalDeviceVideoMaintenance1FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR;
+        PhysicalDeviceVideoMaintenance2FeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR;
+        PhysicalDeviceVulkan11Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
+        PhysicalDeviceVulkan12Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
+        PhysicalDeviceVulkan13Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
+        PhysicalDeviceVulkan14Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES;
+        PhysicalDeviceVulkanMemoryModelFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
+        PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
+        PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
+        PhysicalDeviceYcbcrImageArraysFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
+        PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT;
+        PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
+        std::vector<VkBaseOutStructure *> chain_members{};
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_16BIT_STORAGE_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevice16BitStorageFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_4444_FORMATS_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevice4444FormatsFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_8BIT_STORAGE_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevice8BitStorageFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceASTCDecodeFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceAccelerationStructureFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceAddressBindingReportFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_EXTENSION_NAME))
+            chain_members.push_back(
+                reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceBlendOperationAdvancedFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceBorderColorSwizzleFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceBufferDeviceAddressFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceBufferDeviceAddressFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceColorWriteEnableFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceComputeShaderDerivativesFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceConditionalRenderingFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceCooperativeMatrixFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COPY_MEMORY_INDIRECT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceCopyMemoryIndirectFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceCustomBorderColorFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_CUSTOM_RESOLVE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceCustomResolveFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEPTH_BIAS_CONTROL_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDepthBiasControlFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDepthClampControlFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDepthClampZeroOneFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDepthClipControlFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDepthClipEnableFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDescriptorBufferFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_HEAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDescriptorHeapFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDescriptorIndexingFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DEVICE_ADDRESS_COMMANDS_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDeviceAddressCommandsFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDeviceMemoryReportFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDynamicRenderingFeatures));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDynamicRenderingLocalReadFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_EXTENSION_NAME))
+            chain_members.push_back(
+                reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceExtendedDynamicState2FeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceExtendedDynamicState3FeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceExtendedDynamicStateFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEVICE_FAULT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFaultFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DEVICE_FAULT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFaultFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFragmentDensityMap2FeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFragmentDensityMapFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFragmentShaderBarycentricFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFragmentShaderInterlockFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFragmentShadingRateFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAME_BOUNDARY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceFrameBoundaryFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME) ||
+             gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceGlobalPriorityQueryFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceHostImageCopyFeatures));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceHostQueryResetFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceImage2DViewOf3DFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceImageCompressionControlFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_EXTENSION_NAME))
+            chain_members.push_back(
+                reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceImageRobustnessFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_SLICED_VIEW_OF_3D_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceImageSlicedViewOf3DFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceImageViewMinLodFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceImagelessFramebufferFeatures));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME) ||
+             gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceIndexTypeUint8Features));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceInlineUniformBlockFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_INTERNALLY_SYNCHRONIZED_QUEUES_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LEGACY_DITHERING_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceLegacyDitheringFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LEGACY_VERTEX_ATTRIBUTES_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceLegacyVertexAttributesFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME) ||
+             gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceLineRasterizationFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_10_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance10FeaturesKHR));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_4_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance4Features));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_5_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance5Features));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_6_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance6Features));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_7_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance7FeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_8_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance8FeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_9_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMaintenance9FeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MAP_MEMORY_PLACED_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMapMemoryPlacedFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MEMORY_DECOMPRESSION_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMemoryDecompressionFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMemoryPriorityFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MESH_SHADER_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMeshShaderFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MULTI_DRAW_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMultiDrawFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME))
+            chain_members.push_back(
+                reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MULTIVIEW_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMultiviewFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceMutableDescriptorTypeFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_NESTED_COMMAND_BUFFER_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceNestedCommandBufferFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_NON_SEAMLESS_CUBE_MAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceNonSeamlessCubeMapFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_OPACITY_MICROMAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceOpacityMicromapFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePerformanceQueryFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PIPELINE_BINARY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePipelineBinaryFeaturesKHR));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePipelineCreationCacheControlFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePipelineExecutablePropertiesFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_PROPERTIES_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePipelinePropertiesFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePipelineProtectedAccessFeatures));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePipelineRobustnessFeatures));
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePortabilitySubsetFeaturesKHR));
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PRESENT_ID_2_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePresentId2FeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PRESENT_ID_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePresentIdFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRESENT_TIMING_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePresentTimingFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PRESENT_WAIT_2_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePresentWait2FeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PRESENT_WAIT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePresentWaitFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRIVATE_DATA_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDevicePrivateDataFeatures));
+        if (gpu.api_version == VK_API_VERSION_1_1 || show_promoted_structs)
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceProtectedMemoryFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceProvokingVertexFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_RGBA10X6_FORMATS_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceRGBA10X6FormatsFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME))
+            chain_members.push_back(
+                reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_RAY_QUERY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceRayQueryFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceRayTracingInvocationReorderFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_RAY_TRACING_MAINTENANCE_1_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceRayTracingMaintenance1FeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceRayTracingPipelineFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_RAY_TRACING_POSITION_FETCH_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceRayTracingPositionFetchFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_ROBUSTNESS_2_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceRobustness2FeaturesKHR));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceSamplerYcbcrConversionFeatures));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceScalarBlockLayoutFeatures));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceSeparateDepthStencilLayoutsFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_64BIT_INDEXING_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShader64BitIndexingFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_ABORT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderAbortFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderAtomicFloat2FeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderAtomicFloatFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderAtomicInt64Features));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_BFLOAT16_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderBfloat16FeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_CLOCK_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderClockFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_CONSTANT_DATA_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderConstantDataFeaturesKHR));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderDemoteToHelperInvocationFeatures));
+        if (gpu.api_version == VK_API_VERSION_1_1 || show_promoted_structs)
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderDrawParametersFeatures));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderExpectAssumeFeatures));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderFloat16Int8Features));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_FLOAT8_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderFloat8FeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderFloatControls2Features));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FMA_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderFmaFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderImageAtomicInt64FeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderIntegerDotProductFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_LONG_VECTOR_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderLongVectorFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderModuleIdentifierFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_OBJECT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderObjectFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderQuadControlFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME))
+            chain_members.push_back(
+                reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_REPLICATED_COMPOSITES_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderReplicatedCompositesFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderSubgroupExtendedTypesFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderSubgroupRotateFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME))
+            chain_members.push_back(
+                reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderTerminateInvocationFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_TILE_IMAGE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderTileImageFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_EXTENSION_NAME))
+            chain_members.push_back(
+                reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_UNTYPED_POINTERS_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceShaderUntypedPointersFeaturesKHR));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceSubgroupSizeControlFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SUBPASS_MERGE_FEEDBACK_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceSubpassMergeFeedbackFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME) ||
+            gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceSwapchainMaintenance1FeaturesKHR));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceSynchronization2Features));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceTexelBufferAlignmentFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceTextureCompressionASTC3DFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceTextureCompressionASTCHDRFeatures));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceTimelineSemaphoreFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceTransformFeedbackFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_UNIFIED_IMAGE_LAYOUTS_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceUnifiedImageLayoutsFeaturesKHR));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceUniformBufferStandardLayoutFeatures));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_1 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVariablePointersFeatures));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME) ||
+             gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVertexAttributeDivisorFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVertexAttributeRobustnessFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVertexInputDynamicStateFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVideoDecodeVP9FeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVideoEncodeAV1FeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVideoMaintenance1FeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_MAINTENANCE_2_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVideoMaintenance2FeaturesKHR));
+        if ((gpu.api_version >= VK_API_VERSION_1_2))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVulkan11Features));
+        if ((gpu.api_version >= VK_API_VERSION_1_2))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVulkan12Features));
+        if ((gpu.api_version >= VK_API_VERSION_1_3))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVulkan13Features));
+        if ((gpu.api_version >= VK_API_VERSION_1_4))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVulkan14Features));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_2 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceVulkanMemoryModelFeatures));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME))
+            chain_members.push_back(
+                reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceYcbcrImageArraysFeaturesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT));
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3 || show_promoted_structs))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures));
+
+        if (!chain_members.empty()) {
+            for (size_t i = 0; i < chain_members.size() - 1; i++) {
+                chain_members[i]->pNext = chain_members[i + 1];
+            }
+            start_of_chain = chain_members[0];
+        }
+    }
+};
+void setup_phys_device_features2_chain(VkPhysicalDeviceFeatures2 &start, std::unique_ptr<phys_device_features2_chain> &chain,
+                                       AppGpu &gpu, bool show_promoted_structs) {
+    chain = std::unique_ptr<phys_device_features2_chain>(new phys_device_features2_chain());
+    chain->initialize_chain(gpu, show_promoted_structs);
+    start.pNext = chain->start_of_chain;
+};
+
+void chain_iterator_phys_device_features2(Printer &p, AppGpu &gpu, bool show_promoted_structs, const void *place) {
+    while (place) {
+        const VkBaseOutStructure *structure = (const VkBaseOutStructure *)place;
+        p.SetSubHeader();
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES) {
+            const VkPhysicalDevice16BitStorageFeatures *props = (const VkPhysicalDevice16BitStorageFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_1 ? "VkPhysicalDevice16BitStorageFeatures"
+                                                                     : ("VkPhysicalDevice16BitStorageFeaturesKHR");
+            DumpVkPhysicalDevice16BitStorageFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDevice16BitStorageFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_16BIT_STORAGE_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDevice16BitStorageFeatures(p, "VkPhysicalDevice16BitStorageFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT) {
+            const VkPhysicalDevice4444FormatsFeaturesEXT *props = (const VkPhysicalDevice4444FormatsFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDevice4444FormatsFeaturesEXT";
+            DumpVkPhysicalDevice4444FormatsFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES) {
+            const VkPhysicalDevice8BitStorageFeatures *props = (const VkPhysicalDevice8BitStorageFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDevice8BitStorageFeatures"
+                                                                     : ("VkPhysicalDevice8BitStorageFeaturesKHR");
+            DumpVkPhysicalDevice8BitStorageFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDevice8BitStorageFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_8BIT_STORAGE_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDevice8BitStorageFeatures(p, "VkPhysicalDevice8BitStorageFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT) {
+            const VkPhysicalDeviceASTCDecodeFeaturesEXT *props = (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceASTCDecodeFeaturesEXT";
+            DumpVkPhysicalDeviceASTCDecodeFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR) {
+            const VkPhysicalDeviceAccelerationStructureFeaturesKHR *props =
+                (const VkPhysicalDeviceAccelerationStructureFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceAccelerationStructureFeaturesKHR";
+            DumpVkPhysicalDeviceAccelerationStructureFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT) {
+            const VkPhysicalDeviceAddressBindingReportFeaturesEXT *props =
+                (const VkPhysicalDeviceAddressBindingReportFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceAddressBindingReportFeaturesEXT";
+            DumpVkPhysicalDeviceAddressBindingReportFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT) {
+            const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *props =
+                (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT";
+            DumpVkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT) {
+            const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *props =
+                (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT";
+            DumpVkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT) {
+            const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *props =
+                (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT";
+            DumpVkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT) {
+            const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *props =
+                (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceBorderColorSwizzleFeaturesEXT";
+            DumpVkPhysicalDeviceBorderColorSwizzleFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES) {
+            const VkPhysicalDeviceBufferDeviceAddressFeatures *props =
+                (const VkPhysicalDeviceBufferDeviceAddressFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceBufferDeviceAddressFeatures"
+                                                                     : ("VkPhysicalDeviceBufferDeviceAddressFeaturesKHR");
+            DumpVkPhysicalDeviceBufferDeviceAddressFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceBufferDeviceAddressFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceBufferDeviceAddressFeatures(p, "VkPhysicalDeviceBufferDeviceAddressFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT) {
+            const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *props =
+                (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceBufferDeviceAddressFeaturesEXT"
+                                   : ("VkPhysicalDeviceBufferAddressFeaturesEXT");
+            DumpVkPhysicalDeviceBufferDeviceAddressFeaturesEXT(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceBufferAddressFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceBufferDeviceAddressFeaturesEXT(p, "VkPhysicalDeviceBufferAddressFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT) {
+            const VkPhysicalDeviceColorWriteEnableFeaturesEXT *props =
+                (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceColorWriteEnableFeaturesEXT";
+            DumpVkPhysicalDeviceColorWriteEnableFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR) {
+            const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *props =
+                (const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR"
+                                   : ("VkPhysicalDeviceComputeShaderDerivativesFeaturesNV");
+            DumpVkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceComputeShaderDerivativesFeaturesNV") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(p, "VkPhysicalDeviceComputeShaderDerivativesFeaturesNV",
+                                                                        *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT) {
+            const VkPhysicalDeviceConditionalRenderingFeaturesEXT *props =
+                (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceConditionalRenderingFeaturesEXT";
+            DumpVkPhysicalDeviceConditionalRenderingFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR) {
+            const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *props =
+                (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceCooperativeMatrixFeaturesKHR";
+            DumpVkPhysicalDeviceCooperativeMatrixFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR) {
+            const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *props =
+                (const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR";
+            DumpVkPhysicalDeviceCopyMemoryIndirectFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT) {
+            const VkPhysicalDeviceCustomBorderColorFeaturesEXT *props =
+                (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceCustomBorderColorFeaturesEXT";
+            DumpVkPhysicalDeviceCustomBorderColorFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT) {
+            const VkPhysicalDeviceCustomResolveFeaturesEXT *props = (const VkPhysicalDeviceCustomResolveFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceCustomResolveFeaturesEXT";
+            DumpVkPhysicalDeviceCustomResolveFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT) {
+            const VkPhysicalDeviceDepthBiasControlFeaturesEXT *props =
+                (const VkPhysicalDeviceDepthBiasControlFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDepthBiasControlFeaturesEXT";
+            DumpVkPhysicalDeviceDepthBiasControlFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT) {
+            const VkPhysicalDeviceDepthClampControlFeaturesEXT *props =
+                (const VkPhysicalDeviceDepthClampControlFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDepthClampControlFeaturesEXT";
+            DumpVkPhysicalDeviceDepthClampControlFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR) {
+            const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *props =
+                (const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceDepthClampZeroOneFeaturesKHR"
+                                   : ("VkPhysicalDeviceDepthClampZeroOneFeaturesEXT");
+            DumpVkPhysicalDeviceDepthClampZeroOneFeaturesKHR(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceDepthClampZeroOneFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceDepthClampZeroOneFeaturesKHR(p, "VkPhysicalDeviceDepthClampZeroOneFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT) {
+            const VkPhysicalDeviceDepthClipControlFeaturesEXT *props =
+                (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDepthClipControlFeaturesEXT";
+            DumpVkPhysicalDeviceDepthClipControlFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT) {
+            const VkPhysicalDeviceDepthClipEnableFeaturesEXT *props = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDepthClipEnableFeaturesEXT";
+            DumpVkPhysicalDeviceDepthClipEnableFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT) {
+            const VkPhysicalDeviceDescriptorBufferFeaturesEXT *props =
+                (const VkPhysicalDeviceDescriptorBufferFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDescriptorBufferFeaturesEXT";
+            DumpVkPhysicalDeviceDescriptorBufferFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT) {
+            const VkPhysicalDeviceDescriptorHeapFeaturesEXT *props = (const VkPhysicalDeviceDescriptorHeapFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDescriptorHeapFeaturesEXT";
+            DumpVkPhysicalDeviceDescriptorHeapFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES) {
+            const VkPhysicalDeviceDescriptorIndexingFeatures *props = (const VkPhysicalDeviceDescriptorIndexingFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceDescriptorIndexingFeatures"
+                                                                     : ("VkPhysicalDeviceDescriptorIndexingFeaturesEXT");
+            DumpVkPhysicalDeviceDescriptorIndexingFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceDescriptorIndexingFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceDescriptorIndexingFeatures(p, "VkPhysicalDeviceDescriptorIndexingFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR) {
+            const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR *props =
+                (const VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR";
+            DumpVkPhysicalDeviceDeviceAddressCommandsFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT) {
+            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *props =
+                (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT";
+            DumpVkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT) {
+            const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *props =
+                (const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDeviceMemoryReportFeaturesEXT";
+            DumpVkPhysicalDeviceDeviceMemoryReportFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES) {
+            const VkPhysicalDeviceDynamicRenderingFeatures *props = (const VkPhysicalDeviceDynamicRenderingFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceDynamicRenderingFeatures"
+                                                                     : ("VkPhysicalDeviceDynamicRenderingFeaturesKHR");
+            DumpVkPhysicalDeviceDynamicRenderingFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceDynamicRenderingFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceDynamicRenderingFeatures(p, "VkPhysicalDeviceDynamicRenderingFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES) {
+            const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *props =
+                (const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceDynamicRenderingLocalReadFeatures"
+                                                                     : ("VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR");
+            DumpVkPhysicalDeviceDynamicRenderingLocalReadFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceDynamicRenderingLocalReadFeatures(p, "VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR",
+                                                                      *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT) {
+            const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *props =
+                (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT";
+            DumpVkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT) {
+            const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *props =
+                (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT";
+            DumpVkPhysicalDeviceExtendedDynamicState2FeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT) {
+            const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *props =
+                (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT";
+            DumpVkPhysicalDeviceExtendedDynamicState3FeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT) {
+            const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *props =
+                (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT";
+            DumpVkPhysicalDeviceExtendedDynamicStateFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT) {
+            const VkPhysicalDeviceFaultFeaturesEXT *props = (const VkPhysicalDeviceFaultFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceFaultFeaturesEXT";
+            DumpVkPhysicalDeviceFaultFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_KHR) {
+            const VkPhysicalDeviceFaultFeaturesKHR *props = (const VkPhysicalDeviceFaultFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceFaultFeaturesKHR";
+            DumpVkPhysicalDeviceFaultFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT) {
+            const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *props =
+                (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceFragmentDensityMap2FeaturesEXT";
+            DumpVkPhysicalDeviceFragmentDensityMap2FeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT) {
+            const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *props =
+                (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceFragmentDensityMapFeaturesEXT";
+            DumpVkPhysicalDeviceFragmentDensityMapFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT) {
+            const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *props =
+                (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT"
+                                   : ("VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM");
+            DumpVkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT(p, "VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM",
+                                                                        *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR) {
+            const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *props =
+                (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR"
+                                   : ("VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV");
+            DumpVkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(p, "VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV",
+                                                                         *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT) {
+            const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *props =
+                (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT";
+            DumpVkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR) {
+            const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *props =
+                (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceFragmentShadingRateFeaturesKHR";
+            DumpVkPhysicalDeviceFragmentShadingRateFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT) {
+            const VkPhysicalDeviceFrameBoundaryFeaturesEXT *props = (const VkPhysicalDeviceFrameBoundaryFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceFrameBoundaryFeaturesEXT";
+            DumpVkPhysicalDeviceFrameBoundaryFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES) {
+            const VkPhysicalDeviceGlobalPriorityQueryFeatures *props =
+                (const VkPhysicalDeviceGlobalPriorityQueryFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4
+                                   ? "VkPhysicalDeviceGlobalPriorityQueryFeatures"
+                                   : (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME)
+                                          ? "VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR"
+                                          : ("VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT"));
+            DumpVkPhysicalDeviceGlobalPriorityQueryFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceGlobalPriorityQueryFeatures(p, "VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR", *props);
+            }
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceGlobalPriorityQueryFeatures(p, "VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT) {
+            const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *props =
+                (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT";
+            DumpVkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES) {
+            const VkPhysicalDeviceHostImageCopyFeatures *props = (const VkPhysicalDeviceHostImageCopyFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceHostImageCopyFeatures"
+                                                                     : ("VkPhysicalDeviceHostImageCopyFeaturesEXT");
+            DumpVkPhysicalDeviceHostImageCopyFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceHostImageCopyFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceHostImageCopyFeatures(p, "VkPhysicalDeviceHostImageCopyFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES) {
+            const VkPhysicalDeviceHostQueryResetFeatures *props = (const VkPhysicalDeviceHostQueryResetFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceHostQueryResetFeatures"
+                                                                     : ("VkPhysicalDeviceHostQueryResetFeaturesEXT");
+            DumpVkPhysicalDeviceHostQueryResetFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceHostQueryResetFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceHostQueryResetFeatures(p, "VkPhysicalDeviceHostQueryResetFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT) {
+            const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *props = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceImage2DViewOf3DFeaturesEXT";
+            DumpVkPhysicalDeviceImage2DViewOf3DFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT) {
+            const VkPhysicalDeviceImageCompressionControlFeaturesEXT *props =
+                (const VkPhysicalDeviceImageCompressionControlFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceImageCompressionControlFeaturesEXT";
+            DumpVkPhysicalDeviceImageCompressionControlFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT) {
+            const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *props =
+                (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT";
+            DumpVkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES) {
+            const VkPhysicalDeviceImageRobustnessFeatures *props = (const VkPhysicalDeviceImageRobustnessFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceImageRobustnessFeatures"
+                                                                     : ("VkPhysicalDeviceImageRobustnessFeaturesEXT");
+            DumpVkPhysicalDeviceImageRobustnessFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceImageRobustnessFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceImageRobustnessFeatures(p, "VkPhysicalDeviceImageRobustnessFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT) {
+            const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *props =
+                (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT";
+            DumpVkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT) {
+            const VkPhysicalDeviceImageViewMinLodFeaturesEXT *props = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceImageViewMinLodFeaturesEXT";
+            DumpVkPhysicalDeviceImageViewMinLodFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES) {
+            const VkPhysicalDeviceImagelessFramebufferFeatures *props =
+                (const VkPhysicalDeviceImagelessFramebufferFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceImagelessFramebufferFeatures"
+                                                                     : ("VkPhysicalDeviceImagelessFramebufferFeaturesKHR");
+            DumpVkPhysicalDeviceImagelessFramebufferFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceImagelessFramebufferFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceImagelessFramebufferFeatures(p, "VkPhysicalDeviceImagelessFramebufferFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES) {
+            const VkPhysicalDeviceIndexTypeUint8Features *props = (const VkPhysicalDeviceIndexTypeUint8Features *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4
+                                   ? "VkPhysicalDeviceIndexTypeUint8Features"
+                                   : (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME)
+                                          ? "VkPhysicalDeviceIndexTypeUint8FeaturesKHR"
+                                          : ("VkPhysicalDeviceIndexTypeUint8FeaturesEXT"));
+            DumpVkPhysicalDeviceIndexTypeUint8Features(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceIndexTypeUint8FeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceIndexTypeUint8Features(p, "VkPhysicalDeviceIndexTypeUint8FeaturesKHR", *props);
+            }
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceIndexTypeUint8FeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceIndexTypeUint8Features(p, "VkPhysicalDeviceIndexTypeUint8FeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES) {
+            const VkPhysicalDeviceInlineUniformBlockFeatures *props = (const VkPhysicalDeviceInlineUniformBlockFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceInlineUniformBlockFeatures"
+                                                                     : ("VkPhysicalDeviceInlineUniformBlockFeaturesEXT");
+            DumpVkPhysicalDeviceInlineUniformBlockFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceInlineUniformBlockFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceInlineUniformBlockFeatures(p, "VkPhysicalDeviceInlineUniformBlockFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR) {
+            const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR *props =
+                (const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR";
+            DumpVkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT) {
+            const VkPhysicalDeviceLegacyDitheringFeaturesEXT *props = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceLegacyDitheringFeaturesEXT";
+            DumpVkPhysicalDeviceLegacyDitheringFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT) {
+            const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *props =
+                (const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT";
+            DumpVkPhysicalDeviceLegacyVertexAttributesFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES) {
+            const VkPhysicalDeviceLineRasterizationFeatures *props = (const VkPhysicalDeviceLineRasterizationFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4
+                                   ? "VkPhysicalDeviceLineRasterizationFeatures"
+                                   : (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME)
+                                          ? "VkPhysicalDeviceLineRasterizationFeaturesKHR"
+                                          : ("VkPhysicalDeviceLineRasterizationFeaturesEXT"));
+            DumpVkPhysicalDeviceLineRasterizationFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceLineRasterizationFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceLineRasterizationFeatures(p, "VkPhysicalDeviceLineRasterizationFeaturesKHR", *props);
+            }
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceLineRasterizationFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceLineRasterizationFeatures(p, "VkPhysicalDeviceLineRasterizationFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR) {
+            const VkPhysicalDeviceMaintenance10FeaturesKHR *props = (const VkPhysicalDeviceMaintenance10FeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceMaintenance10FeaturesKHR";
+            DumpVkPhysicalDeviceMaintenance10FeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES) {
+            const VkPhysicalDeviceMaintenance4Features *props = (const VkPhysicalDeviceMaintenance4Features *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceMaintenance4Features"
+                                                                     : ("VkPhysicalDeviceMaintenance4FeaturesKHR");
+            DumpVkPhysicalDeviceMaintenance4Features(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMaintenance4FeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_4_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceMaintenance4Features(p, "VkPhysicalDeviceMaintenance4FeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES) {
+            const VkPhysicalDeviceMaintenance5Features *props = (const VkPhysicalDeviceMaintenance5Features *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceMaintenance5Features"
+                                                                     : ("VkPhysicalDeviceMaintenance5FeaturesKHR");
+            DumpVkPhysicalDeviceMaintenance5Features(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMaintenance5FeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_5_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceMaintenance5Features(p, "VkPhysicalDeviceMaintenance5FeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES) {
+            const VkPhysicalDeviceMaintenance6Features *props = (const VkPhysicalDeviceMaintenance6Features *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceMaintenance6Features"
+                                                                     : ("VkPhysicalDeviceMaintenance6FeaturesKHR");
+            DumpVkPhysicalDeviceMaintenance6Features(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMaintenance6FeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_6_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceMaintenance6Features(p, "VkPhysicalDeviceMaintenance6FeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR) {
+            const VkPhysicalDeviceMaintenance7FeaturesKHR *props = (const VkPhysicalDeviceMaintenance7FeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceMaintenance7FeaturesKHR";
+            DumpVkPhysicalDeviceMaintenance7FeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR) {
+            const VkPhysicalDeviceMaintenance8FeaturesKHR *props = (const VkPhysicalDeviceMaintenance8FeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceMaintenance8FeaturesKHR";
+            DumpVkPhysicalDeviceMaintenance8FeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR) {
+            const VkPhysicalDeviceMaintenance9FeaturesKHR *props = (const VkPhysicalDeviceMaintenance9FeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceMaintenance9FeaturesKHR";
+            DumpVkPhysicalDeviceMaintenance9FeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT) {
+            const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *props = (const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceMapMemoryPlacedFeaturesEXT";
+            DumpVkPhysicalDeviceMapMemoryPlacedFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT) {
+            const VkPhysicalDeviceMemoryDecompressionFeaturesEXT *props =
+                (const VkPhysicalDeviceMemoryDecompressionFeaturesEXT *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MEMORY_DECOMPRESSION_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceMemoryDecompressionFeaturesEXT"
+                                   : ("VkPhysicalDeviceMemoryDecompressionFeaturesNV");
+            DumpVkPhysicalDeviceMemoryDecompressionFeaturesEXT(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMemoryDecompressionFeaturesNV") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceMemoryDecompressionFeaturesEXT(p, "VkPhysicalDeviceMemoryDecompressionFeaturesNV", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT) {
+            const VkPhysicalDeviceMemoryPriorityFeaturesEXT *props = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceMemoryPriorityFeaturesEXT";
+            DumpVkPhysicalDeviceMemoryPriorityFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT) {
+            const VkPhysicalDeviceMeshShaderFeaturesEXT *props = (const VkPhysicalDeviceMeshShaderFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceMeshShaderFeaturesEXT";
+            DumpVkPhysicalDeviceMeshShaderFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT) {
+            const VkPhysicalDeviceMultiDrawFeaturesEXT *props = (const VkPhysicalDeviceMultiDrawFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceMultiDrawFeaturesEXT";
+            DumpVkPhysicalDeviceMultiDrawFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT) {
+            const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *props =
+                (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT";
+            DumpVkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES) {
+            const VkPhysicalDeviceMultiviewFeatures *props = (const VkPhysicalDeviceMultiviewFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_1 ? "VkPhysicalDeviceMultiviewFeatures"
+                                                                     : ("VkPhysicalDeviceMultiviewFeaturesKHR");
+            DumpVkPhysicalDeviceMultiviewFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMultiviewFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MULTIVIEW_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceMultiviewFeatures(p, "VkPhysicalDeviceMultiviewFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT) {
+            const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *props =
+                (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT"
+                                   : ("VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE");
+            DumpVkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(p, "VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE",
+                                                                     *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT) {
+            const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *props =
+                (const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceNestedCommandBufferFeaturesEXT";
+            DumpVkPhysicalDeviceNestedCommandBufferFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT) {
+            const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *props =
+                (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT";
+            DumpVkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT) {
+            const VkPhysicalDeviceOpacityMicromapFeaturesEXT *props = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceOpacityMicromapFeaturesEXT";
+            DumpVkPhysicalDeviceOpacityMicromapFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT) {
+            const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *props =
+                (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT";
+            DumpVkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR) {
+            const VkPhysicalDevicePerformanceQueryFeaturesKHR *props =
+                (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDevicePerformanceQueryFeaturesKHR";
+            DumpVkPhysicalDevicePerformanceQueryFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR) {
+            const VkPhysicalDevicePipelineBinaryFeaturesKHR *props = (const VkPhysicalDevicePipelineBinaryFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDevicePipelineBinaryFeaturesKHR";
+            DumpVkPhysicalDevicePipelineBinaryFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES) {
+            const VkPhysicalDevicePipelineCreationCacheControlFeatures *props =
+                (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDevicePipelineCreationCacheControlFeatures"
+                                                                     : ("VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT");
+            DumpVkPhysicalDevicePipelineCreationCacheControlFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDevicePipelineCreationCacheControlFeatures(
+                    p, "VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR) {
+            const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *props =
+                (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR";
+            DumpVkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT) {
+            const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *props =
+                (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT";
+            DumpVkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT) {
+            const VkPhysicalDevicePipelinePropertiesFeaturesEXT *props =
+                (const VkPhysicalDevicePipelinePropertiesFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDevicePipelinePropertiesFeaturesEXT";
+            DumpVkPhysicalDevicePipelinePropertiesFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES) {
+            const VkPhysicalDevicePipelineProtectedAccessFeatures *props =
+                (const VkPhysicalDevicePipelineProtectedAccessFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDevicePipelineProtectedAccessFeatures"
+                                                                     : ("VkPhysicalDevicePipelineProtectedAccessFeaturesEXT");
+            DumpVkPhysicalDevicePipelineProtectedAccessFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePipelineProtectedAccessFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDevicePipelineProtectedAccessFeatures(p, "VkPhysicalDevicePipelineProtectedAccessFeaturesEXT",
+                                                                    *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES) {
+            const VkPhysicalDevicePipelineRobustnessFeatures *props = (const VkPhysicalDevicePipelineRobustnessFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDevicePipelineRobustnessFeatures"
+                                                                     : ("VkPhysicalDevicePipelineRobustnessFeaturesEXT");
+            DumpVkPhysicalDevicePipelineRobustnessFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePipelineRobustnessFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDevicePipelineRobustnessFeatures(p, "VkPhysicalDevicePipelineRobustnessFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR && p.Type() != OutputType::json) {
+            const VkPhysicalDevicePortabilitySubsetFeaturesKHR *props =
+                (const VkPhysicalDevicePortabilitySubsetFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDevicePortabilitySubsetFeaturesKHR";
+            DumpVkPhysicalDevicePortabilitySubsetFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR) {
+            const VkPhysicalDevicePresentId2FeaturesKHR *props = (const VkPhysicalDevicePresentId2FeaturesKHR *)structure;
+            const char *name = "VkPhysicalDevicePresentId2FeaturesKHR";
+            DumpVkPhysicalDevicePresentId2FeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR) {
+            const VkPhysicalDevicePresentIdFeaturesKHR *props = (const VkPhysicalDevicePresentIdFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDevicePresentIdFeaturesKHR";
+            DumpVkPhysicalDevicePresentIdFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR) {
+            const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *props =
+                (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME)
+                                   ? "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR"
+                                   : ("VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT");
+            DumpVkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR(
+                    p, "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT) {
+            const VkPhysicalDevicePresentTimingFeaturesEXT *props = (const VkPhysicalDevicePresentTimingFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDevicePresentTimingFeaturesEXT";
+            DumpVkPhysicalDevicePresentTimingFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR) {
+            const VkPhysicalDevicePresentWait2FeaturesKHR *props = (const VkPhysicalDevicePresentWait2FeaturesKHR *)structure;
+            const char *name = "VkPhysicalDevicePresentWait2FeaturesKHR";
+            DumpVkPhysicalDevicePresentWait2FeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR) {
+            const VkPhysicalDevicePresentWaitFeaturesKHR *props = (const VkPhysicalDevicePresentWaitFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDevicePresentWaitFeaturesKHR";
+            DumpVkPhysicalDevicePresentWaitFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT) {
+            const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *props =
+                (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT";
+            DumpVkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT) {
+            const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *props =
+                (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT";
+            DumpVkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES) {
+            const VkPhysicalDevicePrivateDataFeatures *props = (const VkPhysicalDevicePrivateDataFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDevicePrivateDataFeatures"
+                                                                     : ("VkPhysicalDevicePrivateDataFeaturesEXT");
+            DumpVkPhysicalDevicePrivateDataFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDevicePrivateDataFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRIVATE_DATA_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDevicePrivateDataFeatures(p, "VkPhysicalDevicePrivateDataFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES) {
+            const VkPhysicalDeviceProtectedMemoryFeatures *props = (const VkPhysicalDeviceProtectedMemoryFeatures *)structure;
+            const char *name = "VkPhysicalDeviceProtectedMemoryFeatures";
+            DumpVkPhysicalDeviceProtectedMemoryFeatures(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT) {
+            const VkPhysicalDeviceProvokingVertexFeaturesEXT *props = (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceProvokingVertexFeaturesEXT";
+            DumpVkPhysicalDeviceProvokingVertexFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT) {
+            const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *props = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT";
+            DumpVkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT) {
+            const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *props =
+                (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT"
+                                   : ("VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM");
+            DumpVkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+                    p, "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR) {
+            const VkPhysicalDeviceRayQueryFeaturesKHR *props = (const VkPhysicalDeviceRayQueryFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceRayQueryFeaturesKHR";
+            DumpVkPhysicalDeviceRayQueryFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT) {
+            const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT *props =
+                (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT";
+            DumpVkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR) {
+            const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *props =
+                (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR";
+            DumpVkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR) {
+            const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *props =
+                (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceRayTracingPipelineFeaturesKHR";
+            DumpVkPhysicalDeviceRayTracingPipelineFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR) {
+            const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *props =
+                (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR";
+            DumpVkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR) {
+            const VkPhysicalDeviceRobustness2FeaturesKHR *props = (const VkPhysicalDeviceRobustness2FeaturesKHR *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_ROBUSTNESS_2_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceRobustness2FeaturesKHR"
+                                   : ("VkPhysicalDeviceRobustness2FeaturesEXT");
+            DumpVkPhysicalDeviceRobustness2FeaturesKHR(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceRobustness2FeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceRobustness2FeaturesKHR(p, "VkPhysicalDeviceRobustness2FeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES) {
+            const VkPhysicalDeviceSamplerYcbcrConversionFeatures *props =
+                (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_1 ? "VkPhysicalDeviceSamplerYcbcrConversionFeatures"
+                                                                     : ("VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR");
+            DumpVkPhysicalDeviceSamplerYcbcrConversionFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceSamplerYcbcrConversionFeatures(p, "VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES) {
+            const VkPhysicalDeviceScalarBlockLayoutFeatures *props = (const VkPhysicalDeviceScalarBlockLayoutFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceScalarBlockLayoutFeatures"
+                                                                     : ("VkPhysicalDeviceScalarBlockLayoutFeaturesEXT");
+            DumpVkPhysicalDeviceScalarBlockLayoutFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceScalarBlockLayoutFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceScalarBlockLayoutFeatures(p, "VkPhysicalDeviceScalarBlockLayoutFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES) {
+            const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *props =
+                (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures"
+                                                                     : ("VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR");
+            DumpVkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(p, "VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR",
+                                                                        *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT) {
+            const VkPhysicalDeviceShader64BitIndexingFeaturesEXT *props =
+                (const VkPhysicalDeviceShader64BitIndexingFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShader64BitIndexingFeaturesEXT";
+            DumpVkPhysicalDeviceShader64BitIndexingFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR) {
+            const VkPhysicalDeviceShaderAbortFeaturesKHR *props = (const VkPhysicalDeviceShaderAbortFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceShaderAbortFeaturesKHR";
+            DumpVkPhysicalDeviceShaderAbortFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT) {
+            const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *props =
+                (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT";
+            DumpVkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT) {
+            const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *props =
+                (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT";
+            DumpVkPhysicalDeviceShaderAtomicFloatFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES) {
+            const VkPhysicalDeviceShaderAtomicInt64Features *props = (const VkPhysicalDeviceShaderAtomicInt64Features *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceShaderAtomicInt64Features"
+                                                                     : ("VkPhysicalDeviceShaderAtomicInt64FeaturesKHR");
+            DumpVkPhysicalDeviceShaderAtomicInt64Features(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderAtomicInt64FeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceShaderAtomicInt64Features(p, "VkPhysicalDeviceShaderAtomicInt64FeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR) {
+            const VkPhysicalDeviceShaderBfloat16FeaturesKHR *props = (const VkPhysicalDeviceShaderBfloat16FeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceShaderBfloat16FeaturesKHR";
+            DumpVkPhysicalDeviceShaderBfloat16FeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR) {
+            const VkPhysicalDeviceShaderClockFeaturesKHR *props = (const VkPhysicalDeviceShaderClockFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceShaderClockFeaturesKHR";
+            DumpVkPhysicalDeviceShaderClockFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR) {
+            const VkPhysicalDeviceShaderConstantDataFeaturesKHR *props =
+                (const VkPhysicalDeviceShaderConstantDataFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceShaderConstantDataFeaturesKHR";
+            DumpVkPhysicalDeviceShaderConstantDataFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES) {
+            const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *props =
+                (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3
+                                   ? "VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures"
+                                   : ("VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT");
+            DumpVkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+                    p, "VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES) {
+            const VkPhysicalDeviceShaderDrawParametersFeatures *props =
+                (const VkPhysicalDeviceShaderDrawParametersFeatures *)structure;
+            const char *name = "VkPhysicalDeviceShaderDrawParametersFeatures";
+            DumpVkPhysicalDeviceShaderDrawParametersFeatures(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES) {
+            const VkPhysicalDeviceShaderExpectAssumeFeatures *props = (const VkPhysicalDeviceShaderExpectAssumeFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceShaderExpectAssumeFeatures"
+                                                                     : ("VkPhysicalDeviceShaderExpectAssumeFeaturesKHR");
+            DumpVkPhysicalDeviceShaderExpectAssumeFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderExpectAssumeFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceShaderExpectAssumeFeatures(p, "VkPhysicalDeviceShaderExpectAssumeFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES) {
+            const VkPhysicalDeviceShaderFloat16Int8Features *props = (const VkPhysicalDeviceShaderFloat16Int8Features *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2
+                                   ? "VkPhysicalDeviceShaderFloat16Int8Features"
+                                   : (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME)
+                                          ? "VkPhysicalDeviceShaderFloat16Int8FeaturesKHR"
+                                          : ("VkPhysicalDeviceFloat16Int8FeaturesKHR"));
+            DumpVkPhysicalDeviceShaderFloat16Int8Features(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderFloat16Int8FeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceShaderFloat16Int8Features(p, "VkPhysicalDeviceShaderFloat16Int8FeaturesKHR", *props);
+            }
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceFloat16Int8FeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceShaderFloat16Int8Features(p, "VkPhysicalDeviceFloat16Int8FeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT) {
+            const VkPhysicalDeviceShaderFloat8FeaturesEXT *props = (const VkPhysicalDeviceShaderFloat8FeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderFloat8FeaturesEXT";
+            DumpVkPhysicalDeviceShaderFloat8FeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES) {
+            const VkPhysicalDeviceShaderFloatControls2Features *props =
+                (const VkPhysicalDeviceShaderFloatControls2Features *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceShaderFloatControls2Features"
+                                                                     : ("VkPhysicalDeviceShaderFloatControls2FeaturesKHR");
+            DumpVkPhysicalDeviceShaderFloatControls2Features(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderFloatControls2FeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceShaderFloatControls2Features(p, "VkPhysicalDeviceShaderFloatControls2FeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR) {
+            const VkPhysicalDeviceShaderFmaFeaturesKHR *props = (const VkPhysicalDeviceShaderFmaFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceShaderFmaFeaturesKHR";
+            DumpVkPhysicalDeviceShaderFmaFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT) {
+            const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *props =
+                (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT";
+            DumpVkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES) {
+            const VkPhysicalDeviceShaderIntegerDotProductFeatures *props =
+                (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceShaderIntegerDotProductFeatures"
+                                                                     : ("VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR");
+            DumpVkPhysicalDeviceShaderIntegerDotProductFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceShaderIntegerDotProductFeatures(p, "VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR",
+                                                                    *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT) {
+            const VkPhysicalDeviceShaderLongVectorFeaturesEXT *props =
+                (const VkPhysicalDeviceShaderLongVectorFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderLongVectorFeaturesEXT";
+            DumpVkPhysicalDeviceShaderLongVectorFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR) {
+            const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *props =
+                (const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR";
+            DumpVkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT) {
+            const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *props =
+                (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT";
+            DumpVkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT) {
+            const VkPhysicalDeviceShaderObjectFeaturesEXT *props = (const VkPhysicalDeviceShaderObjectFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderObjectFeaturesEXT";
+            DumpVkPhysicalDeviceShaderObjectFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR) {
+            const VkPhysicalDeviceShaderQuadControlFeaturesKHR *props =
+                (const VkPhysicalDeviceShaderQuadControlFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceShaderQuadControlFeaturesKHR";
+            DumpVkPhysicalDeviceShaderQuadControlFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR) {
+            const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *props =
+                (const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR";
+            DumpVkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT) {
+            const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *props =
+                (const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT";
+            DumpVkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES) {
+            const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *props =
+                (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures"
+                                                                     : ("VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR");
+            DumpVkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(p, "VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR",
+                                                                        *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT) {
+            const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT *props =
+                (const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT";
+            DumpVkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES) {
+            const VkPhysicalDeviceShaderSubgroupRotateFeatures *props =
+                (const VkPhysicalDeviceShaderSubgroupRotateFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4 ? "VkPhysicalDeviceShaderSubgroupRotateFeatures"
+                                                                     : ("VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR");
+            DumpVkPhysicalDeviceShaderSubgroupRotateFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceShaderSubgroupRotateFeatures(p, "VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR) {
+            const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *props =
+                (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR";
+            DumpVkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES) {
+            const VkPhysicalDeviceShaderTerminateInvocationFeatures *props =
+                (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceShaderTerminateInvocationFeatures"
+                                                                     : ("VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR");
+            DumpVkPhysicalDeviceShaderTerminateInvocationFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceShaderTerminateInvocationFeatures(p, "VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR",
+                                                                      *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT) {
+            const VkPhysicalDeviceShaderTileImageFeaturesEXT *props = (const VkPhysicalDeviceShaderTileImageFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderTileImageFeaturesEXT";
+            DumpVkPhysicalDeviceShaderTileImageFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT) {
+            const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT *props =
+                (const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT";
+            DumpVkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR) {
+            const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *props =
+                (const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceShaderUntypedPointersFeaturesKHR";
+            DumpVkPhysicalDeviceShaderUntypedPointersFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES) {
+            const VkPhysicalDeviceSubgroupSizeControlFeatures *props =
+                (const VkPhysicalDeviceSubgroupSizeControlFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceSubgroupSizeControlFeatures"
+                                                                     : ("VkPhysicalDeviceSubgroupSizeControlFeaturesEXT");
+            DumpVkPhysicalDeviceSubgroupSizeControlFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceSubgroupSizeControlFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceSubgroupSizeControlFeatures(p, "VkPhysicalDeviceSubgroupSizeControlFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT) {
+            const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *props =
+                (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT";
+            DumpVkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR) {
+            const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *props =
+                (const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *)structure;
+            const char *name = gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME)
+                                   ? "VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR"
+                                   : ("VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT");
+            DumpVkPhysicalDeviceSwapchainMaintenance1FeaturesKHR(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceSwapchainMaintenance1FeaturesKHR(p, "VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES) {
+            const VkPhysicalDeviceSynchronization2Features *props = (const VkPhysicalDeviceSynchronization2Features *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceSynchronization2Features"
+                                                                     : ("VkPhysicalDeviceSynchronization2FeaturesKHR");
+            DumpVkPhysicalDeviceSynchronization2Features(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceSynchronization2FeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceSynchronization2Features(p, "VkPhysicalDeviceSynchronization2FeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT) {
+            const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *props =
+                (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT";
+            DumpVkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT) {
+            const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT *props =
+                (const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT";
+            DumpVkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES) {
+            const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *props =
+                (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceTextureCompressionASTCHDRFeatures"
+                                                                     : ("VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT");
+            DumpVkPhysicalDeviceTextureCompressionASTCHDRFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceTextureCompressionASTCHDRFeatures(p, "VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT",
+                                                                      *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES) {
+            const VkPhysicalDeviceTimelineSemaphoreFeatures *props = (const VkPhysicalDeviceTimelineSemaphoreFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceTimelineSemaphoreFeatures"
+                                                                     : ("VkPhysicalDeviceTimelineSemaphoreFeaturesKHR");
+            DumpVkPhysicalDeviceTimelineSemaphoreFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceTimelineSemaphoreFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceTimelineSemaphoreFeatures(p, "VkPhysicalDeviceTimelineSemaphoreFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT) {
+            const VkPhysicalDeviceTransformFeedbackFeaturesEXT *props =
+                (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceTransformFeedbackFeaturesEXT";
+            DumpVkPhysicalDeviceTransformFeedbackFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR) {
+            const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *props =
+                (const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR";
+            DumpVkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES) {
+            const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *props =
+                (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceUniformBufferStandardLayoutFeatures"
+                                                                     : ("VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR");
+            DumpVkPhysicalDeviceUniformBufferStandardLayoutFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceUniformBufferStandardLayoutFeatures(p, "VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR",
+                                                                        *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES) {
+            const VkPhysicalDeviceVariablePointersFeatures *props = (const VkPhysicalDeviceVariablePointersFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_1
+                                   ? "VkPhysicalDeviceVariablePointersFeatures"
+                                   : (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME)
+                                          ? "VkPhysicalDeviceVariablePointerFeaturesKHR"
+                                          : ("VkPhysicalDeviceVariablePointersFeaturesKHR"));
+            DumpVkPhysicalDeviceVariablePointersFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceVariablePointerFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceVariablePointersFeatures(p, "VkPhysicalDeviceVariablePointerFeaturesKHR", *props);
+            }
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceVariablePointersFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceVariablePointersFeatures(p, "VkPhysicalDeviceVariablePointersFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES) {
+            const VkPhysicalDeviceVertexAttributeDivisorFeatures *props =
+                (const VkPhysicalDeviceVertexAttributeDivisorFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4
+                                   ? "VkPhysicalDeviceVertexAttributeDivisorFeatures"
+                                   : (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)
+                                          ? "VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR"
+                                          : ("VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT"));
+            DumpVkPhysicalDeviceVertexAttributeDivisorFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceVertexAttributeDivisorFeatures(p, "VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR", *props);
+            }
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceVertexAttributeDivisorFeatures(p, "VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT) {
+            const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *props =
+                (const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT";
+            DumpVkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT) {
+            const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *props =
+                (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT";
+            DumpVkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR) {
+            const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *props = (const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceVideoDecodeVP9FeaturesKHR";
+            DumpVkPhysicalDeviceVideoDecodeVP9FeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR) {
+            const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *props = (const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceVideoEncodeAV1FeaturesKHR";
+            DumpVkPhysicalDeviceVideoEncodeAV1FeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR) {
+            const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *props =
+                (const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR";
+            DumpVkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR) {
+            const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *props =
+                (const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR";
+            DumpVkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR) {
+            const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *props =
+                (const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceVideoMaintenance1FeaturesKHR";
+            DumpVkPhysicalDeviceVideoMaintenance1FeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR) {
+            const VkPhysicalDeviceVideoMaintenance2FeaturesKHR *props =
+                (const VkPhysicalDeviceVideoMaintenance2FeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceVideoMaintenance2FeaturesKHR";
+            DumpVkPhysicalDeviceVideoMaintenance2FeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES) {
+            const VkPhysicalDeviceVulkan11Features *props = (const VkPhysicalDeviceVulkan11Features *)structure;
+            const char *name = "VkPhysicalDeviceVulkan11Features";
+            DumpVkPhysicalDeviceVulkan11Features(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES) {
+            const VkPhysicalDeviceVulkan12Features *props = (const VkPhysicalDeviceVulkan12Features *)structure;
+            const char *name = "VkPhysicalDeviceVulkan12Features";
+            DumpVkPhysicalDeviceVulkan12Features(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES) {
+            const VkPhysicalDeviceVulkan13Features *props = (const VkPhysicalDeviceVulkan13Features *)structure;
+            const char *name = "VkPhysicalDeviceVulkan13Features";
+            DumpVkPhysicalDeviceVulkan13Features(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES) {
+            const VkPhysicalDeviceVulkan14Features *props = (const VkPhysicalDeviceVulkan14Features *)structure;
+            const char *name = "VkPhysicalDeviceVulkan14Features";
+            DumpVkPhysicalDeviceVulkan14Features(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES) {
+            const VkPhysicalDeviceVulkanMemoryModelFeatures *props = (const VkPhysicalDeviceVulkanMemoryModelFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_2 ? "VkPhysicalDeviceVulkanMemoryModelFeatures"
+                                                                     : ("VkPhysicalDeviceVulkanMemoryModelFeaturesKHR");
+            DumpVkPhysicalDeviceVulkanMemoryModelFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceVulkanMemoryModelFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceVulkanMemoryModelFeatures(p, "VkPhysicalDeviceVulkanMemoryModelFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR) {
+            const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *props =
+                (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)structure;
+            const char *name = "VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR";
+            DumpVkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT) {
+            const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *props =
+                (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT";
+            DumpVkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT) {
+            const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *props =
+                (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT";
+            DumpVkPhysicalDeviceYcbcrImageArraysFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT) {
+            const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *props =
+                (const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *)structure;
+            const char *name = "VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT";
+            DumpVkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES) {
+            const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *props =
+                (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures"
+                                                                     : ("VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR");
+            DumpVkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(p, name, *props);
+            if (show_promoted_structs && strcmp(name, "VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR") != 0 &&
+                gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME)) {
+                p.AddNewline();
+                p.SetSubHeader();
+                DumpVkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+                    p, "VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR", *props);
+            }
+            p.AddNewline();
+        }
+        place = structure->pNext;
+    }
+}
+
+bool prepare_phys_device_features2_twocall_chain_vectors(std::unique_ptr<phys_device_features2_chain> &chain) {
+    (void)chain;
+    return false;
+}
+struct surface_capabilities2_chain {
+    surface_capabilities2_chain() = default;
+    surface_capabilities2_chain(const surface_capabilities2_chain &) = delete;
+    surface_capabilities2_chain &operator=(const surface_capabilities2_chain &) = delete;
+    surface_capabilities2_chain(surface_capabilities2_chain &&) = delete;
+    surface_capabilities2_chain &operator=(surface_capabilities2_chain &&) = delete;
+    void *start_of_chain = nullptr;
+    VkPresentTimingSurfaceCapabilitiesEXT PresentTimingSurfaceCapabilitiesEXT{};
+    VkSharedPresentSurfaceCapabilitiesKHR SharedPresentSurfaceCapabilitiesKHR{};
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    VkSurfaceCapabilitiesFullScreenExclusiveEXT SurfaceCapabilitiesFullScreenExclusiveEXT{};
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+    VkSurfaceCapabilitiesPresentId2KHR SurfaceCapabilitiesPresentId2KHR{};
+    VkSurfaceCapabilitiesPresentWait2KHR SurfaceCapabilitiesPresentWait2KHR{};
+    VkSurfaceProtectedCapabilitiesKHR SurfaceProtectedCapabilitiesKHR{};
+    void initialize_chain(AppInstance &inst, AppGpu &gpu) noexcept {
+        PresentTimingSurfaceCapabilitiesEXT.sType = VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT;
+        SharedPresentSurfaceCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        SurfaceCapabilitiesFullScreenExclusiveEXT.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT;
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+        SurfaceCapabilitiesPresentId2KHR.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR;
+        SurfaceCapabilitiesPresentWait2KHR.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR;
+        SurfaceProtectedCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR;
+        std::vector<VkBaseOutStructure *> chain_members{};
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PRESENT_TIMING_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&PresentTimingSurfaceCapabilitiesEXT));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&SharedPresentSurfaceCapabilitiesKHR));
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&SurfaceCapabilitiesFullScreenExclusiveEXT));
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PRESENT_ID_2_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&SurfaceCapabilitiesPresentId2KHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PRESENT_WAIT_2_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&SurfaceCapabilitiesPresentWait2KHR));
+        if (inst.CheckExtensionEnabled(VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&SurfaceProtectedCapabilitiesKHR));
+
+        if (!chain_members.empty()) {
+            for (size_t i = 0; i < chain_members.size() - 1; i++) {
+                chain_members[i]->pNext = chain_members[i + 1];
+            }
+            start_of_chain = chain_members[0];
+        }
+    }
+};
+void setup_surface_capabilities2_chain(VkSurfaceCapabilities2KHR &start, std::unique_ptr<surface_capabilities2_chain> &chain,
+                                       AppInstance &inst, AppGpu &gpu) {
+    chain = std::unique_ptr<surface_capabilities2_chain>(new surface_capabilities2_chain());
+    chain->initialize_chain(inst, gpu);
+    start.pNext = chain->start_of_chain;
+};
+
+void chain_iterator_surface_capabilities2(Printer &p, AppInstance &inst, AppGpu &gpu, const void *place) {
+    while (place) {
+        const VkBaseOutStructure *structure = (const VkBaseOutStructure *)place;
+        p.SetSubHeader();
+        if (structure->sType == VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT) {
+            const VkPresentTimingSurfaceCapabilitiesEXT *props = (const VkPresentTimingSurfaceCapabilitiesEXT *)structure;
+            const char *name = "VkPresentTimingSurfaceCapabilitiesEXT";
+            DumpVkPresentTimingSurfaceCapabilitiesEXT(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR) {
+            const VkSharedPresentSurfaceCapabilitiesKHR *props = (const VkSharedPresentSurfaceCapabilitiesKHR *)structure;
+            const char *name = "VkSharedPresentSurfaceCapabilitiesKHR";
+            DumpVkSharedPresentSurfaceCapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        if (structure->sType == VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT) {
+            const VkSurfaceCapabilitiesFullScreenExclusiveEXT *props =
+                (const VkSurfaceCapabilitiesFullScreenExclusiveEXT *)structure;
+            const char *name = "VkSurfaceCapabilitiesFullScreenExclusiveEXT";
+            DumpVkSurfaceCapabilitiesFullScreenExclusiveEXT(p, name, *props);
+            p.AddNewline();
+        }
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+        if (structure->sType == VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR) {
+            const VkSurfaceCapabilitiesPresentId2KHR *props = (const VkSurfaceCapabilitiesPresentId2KHR *)structure;
+            const char *name = "VkSurfaceCapabilitiesPresentId2KHR";
+            DumpVkSurfaceCapabilitiesPresentId2KHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR) {
+            const VkSurfaceCapabilitiesPresentWait2KHR *props = (const VkSurfaceCapabilitiesPresentWait2KHR *)structure;
+            const char *name = "VkSurfaceCapabilitiesPresentWait2KHR";
+            DumpVkSurfaceCapabilitiesPresentWait2KHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR) {
+            const VkSurfaceProtectedCapabilitiesKHR *props = (const VkSurfaceProtectedCapabilitiesKHR *)structure;
+            const char *name = "VkSurfaceProtectedCapabilitiesKHR";
+            DumpVkSurfaceProtectedCapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        place = structure->pNext;
+    }
+}
+
+bool prepare_surface_capabilities2_twocall_chain_vectors(std::unique_ptr<surface_capabilities2_chain> &chain) {
+    (void)chain;
+    return false;
+}
+struct format_properties2_chain {
+    format_properties2_chain() = default;
+    format_properties2_chain(const format_properties2_chain &) = delete;
+    format_properties2_chain &operator=(const format_properties2_chain &) = delete;
+    format_properties2_chain(format_properties2_chain &&) = delete;
+    format_properties2_chain &operator=(format_properties2_chain &&) = delete;
+    void *start_of_chain = nullptr;
+    VkFormatProperties3 FormatProperties3{};
+    VkSubpassResolvePerformanceQueryEXT SubpassResolvePerformanceQueryEXT{};
+    void initialize_chain(AppGpu &gpu) noexcept {
+        FormatProperties3.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3;
+        SubpassResolvePerformanceQueryEXT.sType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT;
+        std::vector<VkBaseOutStructure *> chain_members{};
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_3))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&FormatProperties3));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&SubpassResolvePerformanceQueryEXT));
+
+        if (!chain_members.empty()) {
+            for (size_t i = 0; i < chain_members.size() - 1; i++) {
+                chain_members[i]->pNext = chain_members[i + 1];
+            }
+            start_of_chain = chain_members[0];
+        }
+    }
+};
+void setup_format_properties2_chain(VkFormatProperties2 &start, std::unique_ptr<format_properties2_chain> &chain, AppGpu &gpu) {
+    chain = std::unique_ptr<format_properties2_chain>(new format_properties2_chain());
+    chain->initialize_chain(gpu);
+    start.pNext = chain->start_of_chain;
+};
+
+void chain_iterator_format_properties2(Printer &p, AppGpu &gpu, const void *place) {
+    while (place) {
+        const VkBaseOutStructure *structure = (const VkBaseOutStructure *)place;
+        p.SetSubHeader();
+        if (structure->sType == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3) {
+            const VkFormatProperties3 *props = (const VkFormatProperties3 *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_3 ? "VkFormatProperties3" : ("VkFormatProperties3KHR");
+            DumpVkFormatProperties3(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT) {
+            const VkSubpassResolvePerformanceQueryEXT *props = (const VkSubpassResolvePerformanceQueryEXT *)structure;
+            const char *name = "VkSubpassResolvePerformanceQueryEXT";
+            DumpVkSubpassResolvePerformanceQueryEXT(p, name, *props);
+            p.AddNewline();
+        }
+        place = structure->pNext;
+    }
+}
+
+bool prepare_format_properties2_twocall_chain_vectors(std::unique_ptr<format_properties2_chain> &chain) {
+    (void)chain;
+    return false;
+}
+struct queue_properties2_chain {
+    queue_properties2_chain() = default;
+    queue_properties2_chain(const queue_properties2_chain &) = delete;
+    queue_properties2_chain &operator=(const queue_properties2_chain &) = delete;
+    queue_properties2_chain(queue_properties2_chain &&) = delete;
+    queue_properties2_chain &operator=(queue_properties2_chain &&) = delete;
+    void *start_of_chain = nullptr;
+    VkQueueFamilyGlobalPriorityProperties QueueFamilyGlobalPriorityProperties{};
+    VkQueueFamilyOwnershipTransferPropertiesKHR QueueFamilyOwnershipTransferPropertiesKHR{};
+    VkQueueFamilyQueryResultStatusPropertiesKHR QueueFamilyQueryResultStatusPropertiesKHR{};
+    VkQueueFamilyVideoPropertiesKHR QueueFamilyVideoPropertiesKHR{};
+    void initialize_chain(AppGpu &gpu) noexcept {
+        QueueFamilyGlobalPriorityProperties.sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES;
+        QueueFamilyOwnershipTransferPropertiesKHR.sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR;
+        QueueFamilyQueryResultStatusPropertiesKHR.sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR;
+        QueueFamilyVideoPropertiesKHR.sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR;
+        std::vector<VkBaseOutStructure *> chain_members{};
+        if ((gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME) ||
+             gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME)) &&
+            (gpu.api_version < VK_API_VERSION_1_4))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&QueueFamilyGlobalPriorityProperties));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_MAINTENANCE_9_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&QueueFamilyOwnershipTransferPropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_QUEUE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&QueueFamilyQueryResultStatusPropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_QUEUE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&QueueFamilyVideoPropertiesKHR));
+
+        if (!chain_members.empty()) {
+            for (size_t i = 0; i < chain_members.size() - 1; i++) {
+                chain_members[i]->pNext = chain_members[i + 1];
+            }
+            start_of_chain = chain_members[0];
+        }
+    }
+};
+void setup_queue_properties2_chain(VkQueueFamilyProperties2 &start, std::unique_ptr<queue_properties2_chain> &chain, AppGpu &gpu) {
+    chain = std::unique_ptr<queue_properties2_chain>(new queue_properties2_chain());
+    chain->initialize_chain(gpu);
+    start.pNext = chain->start_of_chain;
+};
+
+void chain_iterator_queue_properties2(Printer &p, AppGpu &gpu, const void *place) {
+    while (place) {
+        const VkBaseOutStructure *structure = (const VkBaseOutStructure *)place;
+        p.SetSubHeader();
+        if (structure->sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES) {
+            const VkQueueFamilyGlobalPriorityProperties *props = (const VkQueueFamilyGlobalPriorityProperties *)structure;
+            const char *name = gpu.api_version >= VK_API_VERSION_1_4
+                                   ? "VkQueueFamilyGlobalPriorityProperties"
+                                   : (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME)
+                                          ? "VkQueueFamilyGlobalPriorityPropertiesKHR"
+                                          : ("VkQueueFamilyGlobalPriorityPropertiesEXT"));
+            DumpVkQueueFamilyGlobalPriorityProperties(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR) {
+            const VkQueueFamilyOwnershipTransferPropertiesKHR *props =
+                (const VkQueueFamilyOwnershipTransferPropertiesKHR *)structure;
+            const char *name = "VkQueueFamilyOwnershipTransferPropertiesKHR";
+            DumpVkQueueFamilyOwnershipTransferPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR) {
+            const VkQueueFamilyQueryResultStatusPropertiesKHR *props =
+                (const VkQueueFamilyQueryResultStatusPropertiesKHR *)structure;
+            const char *name = "VkQueueFamilyQueryResultStatusPropertiesKHR";
+            DumpVkQueueFamilyQueryResultStatusPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR) {
+            const VkQueueFamilyVideoPropertiesKHR *props = (const VkQueueFamilyVideoPropertiesKHR *)structure;
+            const char *name = "VkQueueFamilyVideoPropertiesKHR";
+            DumpVkQueueFamilyVideoPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        place = structure->pNext;
+    }
+}
+
+bool prepare_queue_properties2_twocall_chain_vectors(std::unique_ptr<queue_properties2_chain> &chain) {
+    (void)chain;
+    return false;
+}
+struct video_profile_info_chain {
+    video_profile_info_chain() = default;
+    video_profile_info_chain(const video_profile_info_chain &) = delete;
+    video_profile_info_chain &operator=(const video_profile_info_chain &) = delete;
+    video_profile_info_chain(video_profile_info_chain &&) = delete;
+    video_profile_info_chain &operator=(video_profile_info_chain &&) = delete;
+    void *start_of_chain = nullptr;
+    VkVideoDecodeAV1ProfileInfoKHR VideoDecodeAV1ProfileInfoKHR{};
+    VkVideoDecodeH264ProfileInfoKHR VideoDecodeH264ProfileInfoKHR{};
+    VkVideoDecodeH265ProfileInfoKHR VideoDecodeH265ProfileInfoKHR{};
+    VkVideoDecodeUsageInfoKHR VideoDecodeUsageInfoKHR{};
+    VkVideoDecodeVP9ProfileInfoKHR VideoDecodeVP9ProfileInfoKHR{};
+    VkVideoEncodeAV1ProfileInfoKHR VideoEncodeAV1ProfileInfoKHR{};
+    VkVideoEncodeH264ProfileInfoKHR VideoEncodeH264ProfileInfoKHR{};
+    VkVideoEncodeH265ProfileInfoKHR VideoEncodeH265ProfileInfoKHR{};
+    VkVideoEncodeProfileRgbConversionInfoVALVE VideoEncodeProfileRgbConversionInfoVALVE{};
+    VkVideoEncodeUsageInfoKHR VideoEncodeUsageInfoKHR{};
+    void initialize_chain(AppGpu &gpu) noexcept {
+        VideoDecodeAV1ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR;
+        VideoDecodeH264ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR;
+        VideoDecodeH265ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR;
+        VideoDecodeUsageInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR;
+        VideoDecodeVP9ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR;
+        VideoEncodeAV1ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR;
+        VideoEncodeH264ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR;
+        VideoEncodeH265ProfileInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR;
+        VideoEncodeProfileRgbConversionInfoVALVE.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE;
+        VideoEncodeUsageInfoKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR;
+        std::vector<VkBaseOutStructure *> chain_members{};
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoDecodeAV1ProfileInfoKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoDecodeH264ProfileInfoKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoDecodeH265ProfileInfoKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoDecodeUsageInfoKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoDecodeVP9ProfileInfoKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeAV1ProfileInfoKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeH264ProfileInfoKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeH265ProfileInfoKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeProfileRgbConversionInfoVALVE));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeUsageInfoKHR));
+
+        if (!chain_members.empty()) {
+            for (size_t i = 0; i < chain_members.size() - 1; i++) {
+                chain_members[i]->pNext = chain_members[i + 1];
+            }
+            start_of_chain = chain_members[0];
+        }
+    }
+};
+void setup_video_profile_info_chain(VkVideoProfileInfoKHR &start, std::unique_ptr<video_profile_info_chain> &chain, AppGpu &gpu) {
+    chain = std::unique_ptr<video_profile_info_chain>(new video_profile_info_chain());
+    chain->initialize_chain(gpu);
+    start.pNext = chain->start_of_chain;
+};
+
+void chain_iterator_video_profile_info(Printer &p, AppGpu &gpu, const void *place) {
+    while (place) {
+        const VkBaseOutStructure *structure = (const VkBaseOutStructure *)place;
+        p.SetSubHeader();
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR) {
+            const VkVideoDecodeAV1ProfileInfoKHR *props = (const VkVideoDecodeAV1ProfileInfoKHR *)structure;
+            const char *name = "VkVideoDecodeAV1ProfileInfoKHR";
+            DumpVkVideoDecodeAV1ProfileInfoKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR) {
+            const VkVideoDecodeH264ProfileInfoKHR *props = (const VkVideoDecodeH264ProfileInfoKHR *)structure;
+            const char *name = "VkVideoDecodeH264ProfileInfoKHR";
+            DumpVkVideoDecodeH264ProfileInfoKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR) {
+            const VkVideoDecodeH265ProfileInfoKHR *props = (const VkVideoDecodeH265ProfileInfoKHR *)structure;
+            const char *name = "VkVideoDecodeH265ProfileInfoKHR";
+            DumpVkVideoDecodeH265ProfileInfoKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR) {
+            const VkVideoDecodeUsageInfoKHR *props = (const VkVideoDecodeUsageInfoKHR *)structure;
+            const char *name = "VkVideoDecodeUsageInfoKHR";
+            DumpVkVideoDecodeUsageInfoKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR) {
+            const VkVideoDecodeVP9ProfileInfoKHR *props = (const VkVideoDecodeVP9ProfileInfoKHR *)structure;
+            const char *name = "VkVideoDecodeVP9ProfileInfoKHR";
+            DumpVkVideoDecodeVP9ProfileInfoKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR) {
+            const VkVideoEncodeAV1ProfileInfoKHR *props = (const VkVideoEncodeAV1ProfileInfoKHR *)structure;
+            const char *name = "VkVideoEncodeAV1ProfileInfoKHR";
+            DumpVkVideoEncodeAV1ProfileInfoKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR) {
+            const VkVideoEncodeH264ProfileInfoKHR *props = (const VkVideoEncodeH264ProfileInfoKHR *)structure;
+            const char *name = "VkVideoEncodeH264ProfileInfoKHR";
+            DumpVkVideoEncodeH264ProfileInfoKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR) {
+            const VkVideoEncodeH265ProfileInfoKHR *props = (const VkVideoEncodeH265ProfileInfoKHR *)structure;
+            const char *name = "VkVideoEncodeH265ProfileInfoKHR";
+            DumpVkVideoEncodeH265ProfileInfoKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE) {
+            const VkVideoEncodeProfileRgbConversionInfoVALVE *props = (const VkVideoEncodeProfileRgbConversionInfoVALVE *)structure;
+            const char *name = "VkVideoEncodeProfileRgbConversionInfoVALVE";
+            DumpVkVideoEncodeProfileRgbConversionInfoVALVE(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR) {
+            const VkVideoEncodeUsageInfoKHR *props = (const VkVideoEncodeUsageInfoKHR *)structure;
+            const char *name = "VkVideoEncodeUsageInfoKHR";
+            DumpVkVideoEncodeUsageInfoKHR(p, name, *props);
+            p.AddNewline();
+        }
+        place = structure->pNext;
+    }
+}
+
+bool prepare_video_profile_info_twocall_chain_vectors(std::unique_ptr<video_profile_info_chain> &chain) {
+    (void)chain;
+    return false;
+}
+struct video_capabilities_chain {
+    video_capabilities_chain() = default;
+    video_capabilities_chain(const video_capabilities_chain &) = delete;
+    video_capabilities_chain &operator=(const video_capabilities_chain &) = delete;
+    video_capabilities_chain(video_capabilities_chain &&) = delete;
+    video_capabilities_chain &operator=(video_capabilities_chain &&) = delete;
+    void *start_of_chain = nullptr;
+    VkVideoDecodeAV1CapabilitiesKHR VideoDecodeAV1CapabilitiesKHR{};
+    VkVideoDecodeCapabilitiesKHR VideoDecodeCapabilitiesKHR{};
+    VkVideoDecodeH264CapabilitiesKHR VideoDecodeH264CapabilitiesKHR{};
+    VkVideoDecodeH265CapabilitiesKHR VideoDecodeH265CapabilitiesKHR{};
+    VkVideoDecodeVP9CapabilitiesKHR VideoDecodeVP9CapabilitiesKHR{};
+    VkVideoEncodeAV1CapabilitiesKHR VideoEncodeAV1CapabilitiesKHR{};
+    VkVideoEncodeAV1QuantizationMapCapabilitiesKHR VideoEncodeAV1QuantizationMapCapabilitiesKHR{};
+    VkVideoEncodeCapabilitiesKHR VideoEncodeCapabilitiesKHR{};
+    VkVideoEncodeH264CapabilitiesKHR VideoEncodeH264CapabilitiesKHR{};
+    VkVideoEncodeH264QuantizationMapCapabilitiesKHR VideoEncodeH264QuantizationMapCapabilitiesKHR{};
+    VkVideoEncodeH265CapabilitiesKHR VideoEncodeH265CapabilitiesKHR{};
+    VkVideoEncodeH265QuantizationMapCapabilitiesKHR VideoEncodeH265QuantizationMapCapabilitiesKHR{};
+    VkVideoEncodeIntraRefreshCapabilitiesKHR VideoEncodeIntraRefreshCapabilitiesKHR{};
+    VkVideoEncodeQuantizationMapCapabilitiesKHR VideoEncodeQuantizationMapCapabilitiesKHR{};
+    VkVideoEncodeRgbConversionCapabilitiesVALVE VideoEncodeRgbConversionCapabilitiesVALVE{};
+    void initialize_chain(AppGpu &gpu) noexcept {
+        VideoDecodeAV1CapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR;
+        VideoDecodeCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR;
+        VideoDecodeH264CapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR;
+        VideoDecodeH265CapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR;
+        VideoDecodeVP9CapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR;
+        VideoEncodeAV1CapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR;
+        VideoEncodeAV1QuantizationMapCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR;
+        VideoEncodeCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR;
+        VideoEncodeH264CapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR;
+        VideoEncodeH264QuantizationMapCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR;
+        VideoEncodeH265CapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR;
+        VideoEncodeH265QuantizationMapCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR;
+        VideoEncodeIntraRefreshCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR;
+        VideoEncodeQuantizationMapCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR;
+        VideoEncodeRgbConversionCapabilitiesVALVE.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE;
+        std::vector<VkBaseOutStructure *> chain_members{};
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoDecodeAV1CapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoDecodeCapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoDecodeH264CapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoDecodeH265CapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoDecodeVP9CapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeAV1CapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeAV1QuantizationMapCapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeCapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeH264CapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeH264QuantizationMapCapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeH265CapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeH265QuantizationMapCapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeIntraRefreshCapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeQuantizationMapCapabilitiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoEncodeRgbConversionCapabilitiesVALVE));
+
+        if (!chain_members.empty()) {
+            for (size_t i = 0; i < chain_members.size() - 1; i++) {
+                chain_members[i]->pNext = chain_members[i + 1];
+            }
+            start_of_chain = chain_members[0];
+        }
+    }
+};
+void setup_video_capabilities_chain(VkVideoCapabilitiesKHR &start, std::unique_ptr<video_capabilities_chain> &chain, AppGpu &gpu) {
+    chain = std::unique_ptr<video_capabilities_chain>(new video_capabilities_chain());
+    chain->initialize_chain(gpu);
+    start.pNext = chain->start_of_chain;
+};
+
+void chain_iterator_video_capabilities(Printer &p, AppGpu &gpu, const void *place) {
+    while (place) {
+        const VkBaseOutStructure *structure = (const VkBaseOutStructure *)place;
+        p.SetSubHeader();
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR) {
+            const VkVideoDecodeAV1CapabilitiesKHR *props = (const VkVideoDecodeAV1CapabilitiesKHR *)structure;
+            const char *name = "VkVideoDecodeAV1CapabilitiesKHR";
+            DumpVkVideoDecodeAV1CapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR) {
+            const VkVideoDecodeCapabilitiesKHR *props = (const VkVideoDecodeCapabilitiesKHR *)structure;
+            const char *name = "VkVideoDecodeCapabilitiesKHR";
+            DumpVkVideoDecodeCapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR) {
+            const VkVideoDecodeH264CapabilitiesKHR *props = (const VkVideoDecodeH264CapabilitiesKHR *)structure;
+            const char *name = "VkVideoDecodeH264CapabilitiesKHR";
+            DumpVkVideoDecodeH264CapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR) {
+            const VkVideoDecodeH265CapabilitiesKHR *props = (const VkVideoDecodeH265CapabilitiesKHR *)structure;
+            const char *name = "VkVideoDecodeH265CapabilitiesKHR";
+            DumpVkVideoDecodeH265CapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR) {
+            const VkVideoDecodeVP9CapabilitiesKHR *props = (const VkVideoDecodeVP9CapabilitiesKHR *)structure;
+            const char *name = "VkVideoDecodeVP9CapabilitiesKHR";
+            DumpVkVideoDecodeVP9CapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR) {
+            const VkVideoEncodeAV1CapabilitiesKHR *props = (const VkVideoEncodeAV1CapabilitiesKHR *)structure;
+            const char *name = "VkVideoEncodeAV1CapabilitiesKHR";
+            DumpVkVideoEncodeAV1CapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR) {
+            const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *props =
+                (const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *)structure;
+            const char *name = "VkVideoEncodeAV1QuantizationMapCapabilitiesKHR";
+            DumpVkVideoEncodeAV1QuantizationMapCapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR) {
+            const VkVideoEncodeCapabilitiesKHR *props = (const VkVideoEncodeCapabilitiesKHR *)structure;
+            const char *name = "VkVideoEncodeCapabilitiesKHR";
+            DumpVkVideoEncodeCapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR) {
+            const VkVideoEncodeH264CapabilitiesKHR *props = (const VkVideoEncodeH264CapabilitiesKHR *)structure;
+            const char *name = "VkVideoEncodeH264CapabilitiesKHR";
+            DumpVkVideoEncodeH264CapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR) {
+            const VkVideoEncodeH264QuantizationMapCapabilitiesKHR *props =
+                (const VkVideoEncodeH264QuantizationMapCapabilitiesKHR *)structure;
+            const char *name = "VkVideoEncodeH264QuantizationMapCapabilitiesKHR";
+            DumpVkVideoEncodeH264QuantizationMapCapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR) {
+            const VkVideoEncodeH265CapabilitiesKHR *props = (const VkVideoEncodeH265CapabilitiesKHR *)structure;
+            const char *name = "VkVideoEncodeH265CapabilitiesKHR";
+            DumpVkVideoEncodeH265CapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR) {
+            const VkVideoEncodeH265QuantizationMapCapabilitiesKHR *props =
+                (const VkVideoEncodeH265QuantizationMapCapabilitiesKHR *)structure;
+            const char *name = "VkVideoEncodeH265QuantizationMapCapabilitiesKHR";
+            DumpVkVideoEncodeH265QuantizationMapCapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR) {
+            const VkVideoEncodeIntraRefreshCapabilitiesKHR *props = (const VkVideoEncodeIntraRefreshCapabilitiesKHR *)structure;
+            const char *name = "VkVideoEncodeIntraRefreshCapabilitiesKHR";
+            DumpVkVideoEncodeIntraRefreshCapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR) {
+            const VkVideoEncodeQuantizationMapCapabilitiesKHR *props =
+                (const VkVideoEncodeQuantizationMapCapabilitiesKHR *)structure;
+            const char *name = "VkVideoEncodeQuantizationMapCapabilitiesKHR";
+            DumpVkVideoEncodeQuantizationMapCapabilitiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE) {
+            const VkVideoEncodeRgbConversionCapabilitiesVALVE *props =
+                (const VkVideoEncodeRgbConversionCapabilitiesVALVE *)structure;
+            const char *name = "VkVideoEncodeRgbConversionCapabilitiesVALVE";
+            DumpVkVideoEncodeRgbConversionCapabilitiesVALVE(p, name, *props);
+            p.AddNewline();
+        }
+        place = structure->pNext;
+    }
+}
+
+bool prepare_video_capabilities_twocall_chain_vectors(std::unique_ptr<video_capabilities_chain> &chain) {
+    (void)chain;
+    return false;
+}
+struct video_format_properties_chain {
+    video_format_properties_chain() = default;
+    video_format_properties_chain(const video_format_properties_chain &) = delete;
+    video_format_properties_chain &operator=(const video_format_properties_chain &) = delete;
+    video_format_properties_chain(video_format_properties_chain &&) = delete;
+    video_format_properties_chain &operator=(video_format_properties_chain &&) = delete;
+    void *start_of_chain = nullptr;
+    VkVideoFormatAV1QuantizationMapPropertiesKHR VideoFormatAV1QuantizationMapPropertiesKHR{};
+    VkVideoFormatH265QuantizationMapPropertiesKHR VideoFormatH265QuantizationMapPropertiesKHR{};
+    VkVideoFormatQuantizationMapPropertiesKHR VideoFormatQuantizationMapPropertiesKHR{};
+    void initialize_chain(AppGpu &gpu) noexcept {
+        VideoFormatAV1QuantizationMapPropertiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR;
+        VideoFormatH265QuantizationMapPropertiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR;
+        VideoFormatQuantizationMapPropertiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR;
+        std::vector<VkBaseOutStructure *> chain_members{};
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoFormatAV1QuantizationMapPropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoFormatH265QuantizationMapPropertiesKHR));
+        if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME))
+            chain_members.push_back(reinterpret_cast<VkBaseOutStructure *>(&VideoFormatQuantizationMapPropertiesKHR));
+
+        if (!chain_members.empty()) {
+            for (size_t i = 0; i < chain_members.size() - 1; i++) {
+                chain_members[i]->pNext = chain_members[i + 1];
+            }
+            start_of_chain = chain_members[0];
+        }
+    }
+};
+void setup_video_format_properties_chain(VkVideoFormatPropertiesKHR &start, std::unique_ptr<video_format_properties_chain> &chain,
+                                         AppGpu &gpu) {
+    chain = std::unique_ptr<video_format_properties_chain>(new video_format_properties_chain());
+    chain->initialize_chain(gpu);
+    start.pNext = chain->start_of_chain;
+};
+
+void chain_iterator_video_format_properties(Printer &p, AppGpu &gpu, const void *place) {
+    while (place) {
+        const VkBaseOutStructure *structure = (const VkBaseOutStructure *)place;
+        p.SetSubHeader();
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR) {
+            const VkVideoFormatAV1QuantizationMapPropertiesKHR *props =
+                (const VkVideoFormatAV1QuantizationMapPropertiesKHR *)structure;
+            const char *name = "VkVideoFormatAV1QuantizationMapPropertiesKHR";
+            DumpVkVideoFormatAV1QuantizationMapPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR) {
+            const VkVideoFormatH265QuantizationMapPropertiesKHR *props =
+                (const VkVideoFormatH265QuantizationMapPropertiesKHR *)structure;
+            const char *name = "VkVideoFormatH265QuantizationMapPropertiesKHR";
+            DumpVkVideoFormatH265QuantizationMapPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        if (structure->sType == VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR) {
+            const VkVideoFormatQuantizationMapPropertiesKHR *props = (const VkVideoFormatQuantizationMapPropertiesKHR *)structure;
+            const char *name = "VkVideoFormatQuantizationMapPropertiesKHR";
+            DumpVkVideoFormatQuantizationMapPropertiesKHR(p, name, *props);
+            p.AddNewline();
+        }
+        place = structure->pNext;
+    }
+}
+
+bool prepare_video_format_properties_twocall_chain_vectors(std::unique_ptr<video_format_properties_chain> &chain) {
+    (void)chain;
+    return false;
+}
+bool operator==(const VkExtent2D &a, const VkExtent2D b);
+bool operator==(const VkSurfaceCapabilities2EXT &a, const VkSurfaceCapabilities2EXT b);
+bool operator==(const VkSurfaceCapabilities2KHR &a, const VkSurfaceCapabilities2KHR b);
+bool operator==(const VkSurfaceCapabilitiesKHR &a, const VkSurfaceCapabilitiesKHR b);
+bool operator==(const VkSurfaceFormat2KHR &a, const VkSurfaceFormat2KHR b);
+bool operator==(const VkSurfaceFormatKHR &a, const VkSurfaceFormatKHR b);
+bool operator==(const VkExtent2D &a, const VkExtent2D b) { return a.width == b.width && a.height == b.height; }
+bool operator==(const VkSurfaceCapabilities2EXT &a, const VkSurfaceCapabilities2EXT b) {
+    return a.minImageCount == b.minImageCount && a.maxImageCount == b.maxImageCount && a.currentExtent == b.currentExtent &&
+           a.minImageExtent == b.minImageExtent && a.maxImageExtent == b.maxImageExtent &&
+           a.maxImageArrayLayers == b.maxImageArrayLayers && a.supportedTransforms == b.supportedTransforms &&
+           a.currentTransform == b.currentTransform && a.supportedCompositeAlpha == b.supportedCompositeAlpha &&
+           a.supportedUsageFlags == b.supportedUsageFlags && a.supportedSurfaceCounters == b.supportedSurfaceCounters;
+}
+bool operator==(const VkSurfaceCapabilities2KHR &a, const VkSurfaceCapabilities2KHR b) {
+    return a.surfaceCapabilities == b.surfaceCapabilities;
+}
+bool operator==(const VkSurfaceCapabilitiesKHR &a, const VkSurfaceCapabilitiesKHR b) {
+    return a.minImageCount == b.minImageCount && a.maxImageCount == b.maxImageCount && a.currentExtent == b.currentExtent &&
+           a.minImageExtent == b.minImageExtent && a.maxImageExtent == b.maxImageExtent &&
+           a.maxImageArrayLayers == b.maxImageArrayLayers && a.supportedTransforms == b.supportedTransforms &&
+           a.currentTransform == b.currentTransform && a.supportedCompositeAlpha == b.supportedCompositeAlpha &&
+           a.supportedUsageFlags == b.supportedUsageFlags;
+}
+bool operator==(const VkSurfaceFormat2KHR &a, const VkSurfaceFormat2KHR b) { return a.surfaceFormat == b.surfaceFormat; }
+bool operator==(const VkSurfaceFormatKHR &a, const VkSurfaceFormatKHR b) {
+    return a.format == b.format && a.colorSpace == b.colorSpace;
+}
+std::ostream &operator<<(std::ostream &o, VkExtent2D &obj) { return o << "(" << obj.width << ',' << obj.height << ")"; }
+std::ostream &operator<<(std::ostream &o, VkExtent3D &obj) {
+    return o << "(" << obj.width << ',' << obj.height << ',' << obj.depth << ")";
+}
+auto format_ranges = std::array{
+    FormatRange{0, nullptr, static_cast<VkFormat>(0), static_cast<VkFormat>(184)},
+    FormatRange{VK_API_VERSION_1_1, nullptr, static_cast<VkFormat>(1000156000), static_cast<VkFormat>(1000156033)},
+    FormatRange{0, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME, static_cast<VkFormat>(1000156000),
+                static_cast<VkFormat>(1000156033)},
+    FormatRange{VK_API_VERSION_1_3, nullptr, static_cast<VkFormat>(1000330000), static_cast<VkFormat>(1000330003)},
+    FormatRange{0, VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME, static_cast<VkFormat>(1000330000),
+                static_cast<VkFormat>(1000330003)},
+    FormatRange{VK_API_VERSION_1_3, nullptr, static_cast<VkFormat>(1000340000), static_cast<VkFormat>(1000340001)},
+    FormatRange{0, VK_EXT_4444_FORMATS_EXTENSION_NAME, static_cast<VkFormat>(1000340000), static_cast<VkFormat>(1000340001)},
+    FormatRange{VK_API_VERSION_1_3, nullptr, static_cast<VkFormat>(1000066000), static_cast<VkFormat>(1000066013)},
+    FormatRange{0, VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME, static_cast<VkFormat>(1000066000),
+                static_cast<VkFormat>(1000066013)},
+    FormatRange{VK_API_VERSION_1_4, nullptr, static_cast<VkFormat>(1000470000), static_cast<VkFormat>(1000470001)},
+    FormatRange{0, VK_KHR_MAINTENANCE_5_EXTENSION_NAME, static_cast<VkFormat>(1000470000), static_cast<VkFormat>(1000470001)},
+    FormatRange{0, VK_IMG_FORMAT_PVRTC_EXTENSION_NAME, static_cast<VkFormat>(1000054000), static_cast<VkFormat>(1000054007)},
+    FormatRange{0, VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_EXTENSION_NAME, static_cast<VkFormat>(1000288000),
+                static_cast<VkFormat>(1000288029)},
+    FormatRange{0, VK_ARM_TENSORS_EXTENSION_NAME, static_cast<VkFormat>(1000460000), static_cast<VkFormat>(1000460003)},
+    FormatRange{0, VK_NV_OPTICAL_FLOW_EXTENSION_NAME, static_cast<VkFormat>(1000464000), static_cast<VkFormat>(1000464000)},
+    FormatRange{0, VK_ARM_FORMAT_PACK_EXTENSION_NAME, static_cast<VkFormat>(1000609000), static_cast<VkFormat>(1000609013)},
+};
+
+bool is_video_format_same(const VkVideoFormatPropertiesKHR &format_a, const VkVideoFormatPropertiesKHR &format_b) {
+    auto a = reinterpret_cast<const VkBaseInStructure *>(&format_a);
+    auto b = reinterpret_cast<const VkBaseInStructure *>(&format_b);
+    bool same = true;
+    while (same && a != nullptr && b != nullptr) {
+        if (a->sType != b->sType) {
+            // Structure type mismatch (extension structures are expected to be chained in the same order)
+            same = false;
+        } else {
+            switch (a->sType) {
+                case VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR:
+                    same = same && memcmp(reinterpret_cast<const char *>(a) + sizeof(VkBaseInStructure),
+                                          reinterpret_cast<const char *>(b) + sizeof(VkBaseInStructure),
+                                          sizeof(VkVideoFormatPropertiesKHR) - sizeof(VkBaseInStructure)) == 0;
+                    break;
+                case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR:
+                    same = same && memcmp(reinterpret_cast<const char *>(a) + sizeof(VkBaseInStructure),
+                                          reinterpret_cast<const char *>(b) + sizeof(VkBaseInStructure),
+                                          sizeof(VkVideoFormatAV1QuantizationMapPropertiesKHR) - sizeof(VkBaseInStructure)) == 0;
+                    break;
+                case VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR:
+                    same = same && memcmp(reinterpret_cast<const char *>(a) + sizeof(VkBaseInStructure),
+                                          reinterpret_cast<const char *>(b) + sizeof(VkBaseInStructure),
+                                          sizeof(VkVideoFormatH265QuantizationMapPropertiesKHR) - sizeof(VkBaseInStructure)) == 0;
+                    break;
+                case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR:
+                    same = same && memcmp(reinterpret_cast<const char *>(a) + sizeof(VkBaseInStructure),
+                                          reinterpret_cast<const char *>(b) + sizeof(VkBaseInStructure),
+                                          sizeof(VkVideoFormatQuantizationMapPropertiesKHR) - sizeof(VkBaseInStructure)) == 0;
+                    break;
+                default:
+                    // Unexpected structure type
+                    same = false;
+                    break;
+            }
+        }
+        a = a->pNext;
+        b = b->pNext;
+    }
+    return same;
+}
+
+std::vector<std::unique_ptr<AppVideoProfile>> enumerate_supported_video_profiles(AppGpu &gpu) {
+    std::vector<std::unique_ptr<AppVideoProfile>> result{};
+
+    struct ChromaSubsamplingInfo {
+        VkVideoChromaSubsamplingFlagsKHR value;
+        const char *name;
+    };
+    const std::vector<ChromaSubsamplingInfo> chroma_subsampling_list = {
+        {VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR, "4:2:0"},
+        {VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR, "4:2:2"},
+        {VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR, "4:4:4"},
+        {VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR, "monochrome"}};
+
+    struct BitDepthInfo {
+        VkVideoComponentBitDepthFlagsKHR value;
+        const char *name;
+    };
+    const std::vector<BitDepthInfo> bit_depth_list = {{VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, "8"},
+                                                      {VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR, "10"},
+                                                      {VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR, "12"}};
+
+    auto find_caps_struct = [](const VkVideoCapabilitiesKHR &capabilities, VkStructureType stype) -> const VkBaseInStructure * {
+        auto p = reinterpret_cast<const VkBaseInStructure *>(&capabilities);
+        while (p != nullptr) {
+            if (p->sType == stype) {
+                return p;
+            }
+            p = p->pNext;
+        }
+        return nullptr;
+    };
+
+    auto base_format = [](const ChromaSubsamplingInfo &chroma_subsampling, const BitDepthInfo &luma_bit_depth,
+                          const BitDepthInfo &chroma_bit_depth) {
+        std::string result{};
+        result += " (";
+        result += chroma_subsampling.name;
+        result += " ";
+        result += luma_bit_depth.name;
+        if (luma_bit_depth.value != chroma_bit_depth.value) {
+            result += ":";
+            result += chroma_bit_depth.name;
+        }
+        result += "-bit)";
+        return result;
+    };
+
+    auto add_profile = [&](const std::string &name, const VkVideoProfileInfoKHR &profile_info,
+                           AppVideoProfile::CreateProfileInfoChainCb create_profile_info_chain,
+                           AppVideoProfile::CreateCapabilitiesChainCb create_capabilities_chain,
+                           const AppVideoProfile::CreateFormatPropertiesChainCbList &create_format_properties_chain_list,
+                           AppVideoProfile::InitProfileCb init_profile) {
+        auto profile =
+            std::make_unique<AppVideoProfile>(gpu, gpu.phys_device, name, profile_info, create_profile_info_chain,
+                                              create_capabilities_chain, create_format_properties_chain_list, init_profile);
+        if (profile->supported) {
+            result.push_back(std::move(profile));
+        }
+    };
+
+    if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME)) {
+        const std::string codec_name = "H.264 Decode";
+
+        for (auto chroma_subsampling : chroma_subsampling_list) {
+            for (auto luma_bit_depth : bit_depth_list) {
+                for (auto chroma_bit_depth : bit_depth_list) {
+                    if (chroma_subsampling.value == VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR &&
+                        luma_bit_depth.value != chroma_bit_depth.value) {
+                        // Ignore the chroma bit depth dimension for monochrome
+                        continue;
+                    }
+
+                    std::string profile_base_name = codec_name + base_format(chroma_subsampling, luma_bit_depth, chroma_bit_depth);
+                    VkVideoProfileInfoKHR profile_info{VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR,
+                                                       nullptr,
+                                                       VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR,
+                                                       chroma_subsampling.value,
+                                                       luma_bit_depth.value,
+                                                       chroma_bit_depth.value};
+
+                    auto create_profile_info_chain = [&](const void **ppnext) -> std::unique_ptr<video_profile_info_chain> {
+                        auto profile_info_chain = std::make_unique<video_profile_info_chain>();
+                        if (profile_info_chain != nullptr) {
+                            profile_info_chain->VideoDecodeH264ProfileInfoKHR.sType =
+                                VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR;
+                            profile_info_chain->VideoDecodeH264ProfileInfoKHR.pNext = nullptr;
+                            *ppnext = &profile_info_chain->VideoDecodeH264ProfileInfoKHR;
+                            ppnext = &profile_info_chain->VideoDecodeH264ProfileInfoKHR.pNext;
+                        }
+                        return profile_info_chain;
+                    };
+
+                    auto create_capabilities_chain = [&](void **ppnext) -> std::unique_ptr<video_capabilities_chain> {
+                        auto capabilities_chain = std::make_unique<video_capabilities_chain>();
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME)) {
+                                capabilities_chain->VideoDecodeCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR;
+                                capabilities_chain->VideoDecodeCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoDecodeCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoDecodeCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME)) {
+                                capabilities_chain->VideoDecodeH264CapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR;
+                                capabilities_chain->VideoDecodeH264CapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoDecodeH264CapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoDecodeH264CapabilitiesKHR.pNext;
+                            }
+                        }
+                        return capabilities_chain;
+                    };
+
+                    const AppVideoProfile::CreateFormatPropertiesChainCbList create_format_properties_chain_list = {
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Decode Output",
+                            VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "DPB",
+                            VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                    };
+
+                    add_profile(profile_base_name + " Baseline progressive", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_BASELINE;
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout =
+                                        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR;
+                                });
+                    add_profile(profile_base_name + " Main progressive", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_MAIN;
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout =
+                                        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR;
+                                });
+                    add_profile(profile_base_name + " High progressive", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_HIGH;
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout =
+                                        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR;
+                                });
+                    add_profile(profile_base_name + " High 4:4:4 Predictive progressive", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE;
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout =
+                                        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR;
+                                });
+                    add_profile(profile_base_name + " Baseline interlaced (interleaved lines)", profile_info,
+                                create_profile_info_chain, create_capabilities_chain, create_format_properties_chain_list,
+                                [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_BASELINE;
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout =
+                                        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR;
+                                });
+                    add_profile(profile_base_name + " Main interlaced (interleaved lines)", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_MAIN;
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout =
+                                        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR;
+                                });
+                    add_profile(profile_base_name + " High interlaced (interleaved lines)", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_HIGH;
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout =
+                                        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR;
+                                });
+                    add_profile(profile_base_name + " High 4:4:4 Predictive interlaced (interleaved lines)", profile_info,
+                                create_profile_info_chain, create_capabilities_chain, create_format_properties_chain_list,
+                                [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE;
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout =
+                                        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR;
+                                });
+                    add_profile(profile_base_name + " Baseline interlaced (separate planes)", profile_info,
+                                create_profile_info_chain, create_capabilities_chain, create_format_properties_chain_list,
+                                [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_BASELINE;
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout =
+                                        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR;
+                                });
+                    add_profile(profile_base_name + " Main interlaced (separate planes)", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_MAIN;
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout =
+                                        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR;
+                                });
+                    add_profile(profile_base_name + " High interlaced (separate planes)", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_HIGH;
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout =
+                                        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR;
+                                });
+                    add_profile(profile_base_name + " High 4:4:4 Predictive interlaced (separate planes)", profile_info,
+                                create_profile_info_chain, create_capabilities_chain, create_format_properties_chain_list,
+                                [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE;
+                                    profile.profile_info_chain->VideoDecodeH264ProfileInfoKHR.pictureLayout =
+                                        VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR;
+                                });
+                }
+            }
+        }
+    }
+
+    if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME)) {
+        const std::string codec_name = "H.265 Decode";
+
+        for (auto chroma_subsampling : chroma_subsampling_list) {
+            for (auto luma_bit_depth : bit_depth_list) {
+                for (auto chroma_bit_depth : bit_depth_list) {
+                    if (chroma_subsampling.value == VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR &&
+                        luma_bit_depth.value != chroma_bit_depth.value) {
+                        // Ignore the chroma bit depth dimension for monochrome
+                        continue;
+                    }
+
+                    std::string profile_base_name = codec_name + base_format(chroma_subsampling, luma_bit_depth, chroma_bit_depth);
+                    VkVideoProfileInfoKHR profile_info{VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR,
+                                                       nullptr,
+                                                       VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR,
+                                                       chroma_subsampling.value,
+                                                       luma_bit_depth.value,
+                                                       chroma_bit_depth.value};
+
+                    auto create_profile_info_chain = [&](const void **ppnext) -> std::unique_ptr<video_profile_info_chain> {
+                        auto profile_info_chain = std::make_unique<video_profile_info_chain>();
+                        if (profile_info_chain != nullptr) {
+                            profile_info_chain->VideoDecodeH265ProfileInfoKHR.sType =
+                                VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR;
+                            profile_info_chain->VideoDecodeH265ProfileInfoKHR.pNext = nullptr;
+                            *ppnext = &profile_info_chain->VideoDecodeH265ProfileInfoKHR;
+                            ppnext = &profile_info_chain->VideoDecodeH265ProfileInfoKHR.pNext;
+                        }
+                        return profile_info_chain;
+                    };
+
+                    auto create_capabilities_chain = [&](void **ppnext) -> std::unique_ptr<video_capabilities_chain> {
+                        auto capabilities_chain = std::make_unique<video_capabilities_chain>();
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME)) {
+                                capabilities_chain->VideoDecodeCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR;
+                                capabilities_chain->VideoDecodeCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoDecodeCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoDecodeCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME)) {
+                                capabilities_chain->VideoDecodeH265CapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR;
+                                capabilities_chain->VideoDecodeH265CapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoDecodeH265CapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoDecodeH265CapabilitiesKHR.pNext;
+                            }
+                        }
+                        return capabilities_chain;
+                    };
+
+                    const AppVideoProfile::CreateFormatPropertiesChainCbList create_format_properties_chain_list = {
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Decode Output",
+                            VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "DPB",
+                            VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                    };
+
+                    add_profile(profile_base_name + " Main", profile_info, create_profile_info_chain, create_capabilities_chain,
+                                create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH265ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H265_PROFILE_IDC_MAIN;
+                                });
+                    add_profile(profile_base_name + " Main 10", profile_info, create_profile_info_chain, create_capabilities_chain,
+                                create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH265ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H265_PROFILE_IDC_MAIN_10;
+                                });
+                    add_profile(profile_base_name + " Main Still Picture", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH265ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE;
+                                });
+                    add_profile(profile_base_name + " Format range extensions", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH265ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS;
+                                });
+                    add_profile(profile_base_name + " Screen content coding extensions", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeH265ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS;
+                                });
+                }
+            }
+        }
+    }
+
+    if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME)) {
+        const std::string codec_name = "VP9 Decode";
+
+        for (auto chroma_subsampling : chroma_subsampling_list) {
+            for (auto luma_bit_depth : bit_depth_list) {
+                for (auto chroma_bit_depth : bit_depth_list) {
+                    if (chroma_subsampling.value == VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR &&
+                        luma_bit_depth.value != chroma_bit_depth.value) {
+                        // Ignore the chroma bit depth dimension for monochrome
+                        continue;
+                    }
+
+                    std::string profile_base_name = codec_name + base_format(chroma_subsampling, luma_bit_depth, chroma_bit_depth);
+                    VkVideoProfileInfoKHR profile_info{VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR,
+                                                       nullptr,
+                                                       VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR,
+                                                       chroma_subsampling.value,
+                                                       luma_bit_depth.value,
+                                                       chroma_bit_depth.value};
+
+                    auto create_profile_info_chain = [&](const void **ppnext) -> std::unique_ptr<video_profile_info_chain> {
+                        auto profile_info_chain = std::make_unique<video_profile_info_chain>();
+                        if (profile_info_chain != nullptr) {
+                            profile_info_chain->VideoDecodeVP9ProfileInfoKHR.sType =
+                                VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR;
+                            profile_info_chain->VideoDecodeVP9ProfileInfoKHR.pNext = nullptr;
+                            *ppnext = &profile_info_chain->VideoDecodeVP9ProfileInfoKHR;
+                            ppnext = &profile_info_chain->VideoDecodeVP9ProfileInfoKHR.pNext;
+                        }
+                        return profile_info_chain;
+                    };
+
+                    auto create_capabilities_chain = [&](void **ppnext) -> std::unique_ptr<video_capabilities_chain> {
+                        auto capabilities_chain = std::make_unique<video_capabilities_chain>();
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME)) {
+                                capabilities_chain->VideoDecodeCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR;
+                                capabilities_chain->VideoDecodeCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoDecodeCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoDecodeCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME)) {
+                                capabilities_chain->VideoDecodeVP9CapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR;
+                                capabilities_chain->VideoDecodeVP9CapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoDecodeVP9CapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoDecodeVP9CapabilitiesKHR.pNext;
+                            }
+                        }
+                        return capabilities_chain;
+                    };
+
+                    const AppVideoProfile::CreateFormatPropertiesChainCbList create_format_properties_chain_list = {
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Decode Output",
+                            VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "DPB",
+                            VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                    };
+
+                    add_profile(profile_base_name + " Profile 0", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeVP9ProfileInfoKHR.stdProfile = STD_VIDEO_VP9_PROFILE_0;
+                                });
+                    add_profile(profile_base_name + " Profile 1", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeVP9ProfileInfoKHR.stdProfile = STD_VIDEO_VP9_PROFILE_1;
+                                });
+                    add_profile(profile_base_name + " Profile 2", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeVP9ProfileInfoKHR.stdProfile = STD_VIDEO_VP9_PROFILE_2;
+                                });
+                    add_profile(profile_base_name + " Profile 3", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeVP9ProfileInfoKHR.stdProfile = STD_VIDEO_VP9_PROFILE_3;
+                                });
+                }
+            }
+        }
+    }
+
+    if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME)) {
+        const std::string codec_name = "AV1 Decode";
+
+        for (auto chroma_subsampling : chroma_subsampling_list) {
+            for (auto luma_bit_depth : bit_depth_list) {
+                for (auto chroma_bit_depth : bit_depth_list) {
+                    if (chroma_subsampling.value == VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR &&
+                        luma_bit_depth.value != chroma_bit_depth.value) {
+                        // Ignore the chroma bit depth dimension for monochrome
+                        continue;
+                    }
+
+                    std::string profile_base_name = codec_name + base_format(chroma_subsampling, luma_bit_depth, chroma_bit_depth);
+                    VkVideoProfileInfoKHR profile_info{VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR,
+                                                       nullptr,
+                                                       VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR,
+                                                       chroma_subsampling.value,
+                                                       luma_bit_depth.value,
+                                                       chroma_bit_depth.value};
+
+                    auto create_profile_info_chain = [&](const void **ppnext) -> std::unique_ptr<video_profile_info_chain> {
+                        auto profile_info_chain = std::make_unique<video_profile_info_chain>();
+                        if (profile_info_chain != nullptr) {
+                            profile_info_chain->VideoDecodeAV1ProfileInfoKHR.sType =
+                                VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR;
+                            profile_info_chain->VideoDecodeAV1ProfileInfoKHR.pNext = nullptr;
+                            *ppnext = &profile_info_chain->VideoDecodeAV1ProfileInfoKHR;
+                            ppnext = &profile_info_chain->VideoDecodeAV1ProfileInfoKHR.pNext;
+                        }
+                        return profile_info_chain;
+                    };
+
+                    auto create_capabilities_chain = [&](void **ppnext) -> std::unique_ptr<video_capabilities_chain> {
+                        auto capabilities_chain = std::make_unique<video_capabilities_chain>();
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME)) {
+                                capabilities_chain->VideoDecodeCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR;
+                                capabilities_chain->VideoDecodeCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoDecodeCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoDecodeCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME)) {
+                                capabilities_chain->VideoDecodeAV1CapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR;
+                                capabilities_chain->VideoDecodeAV1CapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoDecodeAV1CapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoDecodeAV1CapabilitiesKHR.pNext;
+                            }
+                        }
+                        return capabilities_chain;
+                    };
+
+                    const AppVideoProfile::CreateFormatPropertiesChainCbList create_format_properties_chain_list = {
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Decode Output",
+                            VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "DPB",
+                            VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                    };
+
+                    add_profile(profile_base_name + " Main with film grain support", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.stdProfile =
+                                        STD_VIDEO_AV1_PROFILE_MAIN;
+                                    profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.filmGrainSupport = VK_TRUE;
+                                });
+                    add_profile(profile_base_name + " High with film grain support", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.stdProfile =
+                                        STD_VIDEO_AV1_PROFILE_HIGH;
+                                    profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.filmGrainSupport = VK_TRUE;
+                                });
+                    add_profile(profile_base_name + " Professional with film grain support", profile_info,
+                                create_profile_info_chain, create_capabilities_chain, create_format_properties_chain_list,
+                                [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.stdProfile =
+                                        STD_VIDEO_AV1_PROFILE_PROFESSIONAL;
+                                    profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.filmGrainSupport = VK_TRUE;
+                                });
+                    add_profile(profile_base_name + " Main without film grain support", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.stdProfile =
+                                        STD_VIDEO_AV1_PROFILE_MAIN;
+                                    profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.filmGrainSupport = VK_FALSE;
+                                });
+                    add_profile(profile_base_name + " High without film grain support", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.stdProfile =
+                                        STD_VIDEO_AV1_PROFILE_HIGH;
+                                    profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.filmGrainSupport = VK_FALSE;
+                                });
+                    add_profile(profile_base_name + " Professional without film grain support", profile_info,
+                                create_profile_info_chain, create_capabilities_chain, create_format_properties_chain_list,
+                                [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.stdProfile =
+                                        STD_VIDEO_AV1_PROFILE_PROFESSIONAL;
+                                    profile.profile_info_chain->VideoDecodeAV1ProfileInfoKHR.filmGrainSupport = VK_FALSE;
+                                });
+                }
+            }
+        }
+    }
+
+    if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME)) {
+        const std::string codec_name = "H.264 Encode";
+
+        for (auto chroma_subsampling : chroma_subsampling_list) {
+            for (auto luma_bit_depth : bit_depth_list) {
+                for (auto chroma_bit_depth : bit_depth_list) {
+                    if (chroma_subsampling.value == VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR &&
+                        luma_bit_depth.value != chroma_bit_depth.value) {
+                        // Ignore the chroma bit depth dimension for monochrome
+                        continue;
+                    }
+
+                    std::string profile_base_name = codec_name + base_format(chroma_subsampling, luma_bit_depth, chroma_bit_depth);
+                    VkVideoProfileInfoKHR profile_info{VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR,
+                                                       nullptr,
+                                                       VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR,
+                                                       chroma_subsampling.value,
+                                                       luma_bit_depth.value,
+                                                       chroma_bit_depth.value};
+
+                    auto create_profile_info_chain = [&](const void **ppnext) -> std::unique_ptr<video_profile_info_chain> {
+                        auto profile_info_chain = std::make_unique<video_profile_info_chain>();
+                        if (profile_info_chain != nullptr) {
+                            profile_info_chain->VideoEncodeH264ProfileInfoKHR.sType =
+                                VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR;
+                            profile_info_chain->VideoEncodeH264ProfileInfoKHR.pNext = nullptr;
+                            *ppnext = &profile_info_chain->VideoEncodeH264ProfileInfoKHR;
+                            ppnext = &profile_info_chain->VideoEncodeH264ProfileInfoKHR.pNext;
+                        }
+                        return profile_info_chain;
+                    };
+
+                    auto create_capabilities_chain = [&](void **ppnext) -> std::unique_ptr<video_capabilities_chain> {
+                        auto capabilities_chain = std::make_unique<video_capabilities_chain>();
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE;
+                                capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE;
+                                ppnext = &capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeH264CapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeH264CapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeH264CapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeH264CapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeH264QuantizationMapCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeH264QuantizationMapCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeH264QuantizationMapCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeH264QuantizationMapCapabilitiesKHR.pNext;
+                            }
+                        }
+                        return capabilities_chain;
+                    };
+
+                    const AppVideoProfile::CreateFormatPropertiesChainCbList create_format_properties_chain_list = {
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Encode Input",
+                            VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "DPB",
+                            VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Quantization Delta Map",
+                            VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) {
+                                    auto caps = reinterpret_cast<const VkVideoEncodeCapabilitiesKHR *>(
+                                        find_caps_struct(capabilities, VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR));
+                                    if (caps != nullptr) {
+                                        supported =
+                                            supported &&
+                                            ((caps->flags & VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR) != 0);
+                                    } else {
+                                        supported = false;
+                                    }
+                                } else {
+                                    supported = false;
+                                }
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                if (format_properties_chain != nullptr) {
+                                    if (gpu.CheckPhysicalDeviceExtensionIncluded(
+                                            VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                        format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.sType =
+                                            VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR;
+                                        format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext = nullptr;
+                                        *ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR;
+                                        ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext;
+                                    }
+                                }
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Emphasis Map",
+                            VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) {
+                                    auto caps = reinterpret_cast<const VkVideoEncodeCapabilitiesKHR *>(
+                                        find_caps_struct(capabilities, VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR));
+                                    if (caps != nullptr) {
+                                        supported =
+                                            supported && ((caps->flags & VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR) != 0);
+                                    } else {
+                                        supported = false;
+                                    }
+                                } else {
+                                    supported = false;
+                                }
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                if (format_properties_chain != nullptr) {
+                                    if (gpu.CheckPhysicalDeviceExtensionIncluded(
+                                            VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                        format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.sType =
+                                            VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR;
+                                        format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext = nullptr;
+                                        *ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR;
+                                        ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext;
+                                    }
+                                }
+                                return format_properties_chain;
+                            },
+                        },
+                    };
+
+                    add_profile(profile_base_name + " Baseline", profile_info, create_profile_info_chain, create_capabilities_chain,
+                                create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoEncodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_BASELINE;
+                                });
+                    add_profile(profile_base_name + " Main", profile_info, create_profile_info_chain, create_capabilities_chain,
+                                create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoEncodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_MAIN;
+                                });
+                    add_profile(profile_base_name + " High", profile_info, create_profile_info_chain, create_capabilities_chain,
+                                create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoEncodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_HIGH;
+                                });
+                    add_profile(profile_base_name + " High 4:4:4 Predictive", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoEncodeH264ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE;
+                                });
+                }
+            }
+        }
+    }
+
+    if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME)) {
+        const std::string codec_name = "H.265 Encode";
+
+        for (auto chroma_subsampling : chroma_subsampling_list) {
+            for (auto luma_bit_depth : bit_depth_list) {
+                for (auto chroma_bit_depth : bit_depth_list) {
+                    if (chroma_subsampling.value == VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR &&
+                        luma_bit_depth.value != chroma_bit_depth.value) {
+                        // Ignore the chroma bit depth dimension for monochrome
+                        continue;
+                    }
+
+                    std::string profile_base_name = codec_name + base_format(chroma_subsampling, luma_bit_depth, chroma_bit_depth);
+                    VkVideoProfileInfoKHR profile_info{VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR,
+                                                       nullptr,
+                                                       VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR,
+                                                       chroma_subsampling.value,
+                                                       luma_bit_depth.value,
+                                                       chroma_bit_depth.value};
+
+                    auto create_profile_info_chain = [&](const void **ppnext) -> std::unique_ptr<video_profile_info_chain> {
+                        auto profile_info_chain = std::make_unique<video_profile_info_chain>();
+                        if (profile_info_chain != nullptr) {
+                            profile_info_chain->VideoEncodeH265ProfileInfoKHR.sType =
+                                VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR;
+                            profile_info_chain->VideoEncodeH265ProfileInfoKHR.pNext = nullptr;
+                            *ppnext = &profile_info_chain->VideoEncodeH265ProfileInfoKHR;
+                            ppnext = &profile_info_chain->VideoEncodeH265ProfileInfoKHR.pNext;
+                        }
+                        return profile_info_chain;
+                    };
+
+                    auto create_capabilities_chain = [&](void **ppnext) -> std::unique_ptr<video_capabilities_chain> {
+                        auto capabilities_chain = std::make_unique<video_capabilities_chain>();
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE;
+                                capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE;
+                                ppnext = &capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeH265CapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeH265CapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeH265CapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeH265CapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeH265QuantizationMapCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeH265QuantizationMapCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeH265QuantizationMapCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeH265QuantizationMapCapabilitiesKHR.pNext;
+                            }
+                        }
+                        return capabilities_chain;
+                    };
+
+                    const AppVideoProfile::CreateFormatPropertiesChainCbList create_format_properties_chain_list = {
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Encode Input",
+                            VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "DPB",
+                            VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Quantization Delta Map",
+                            VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) {
+                                    auto caps = reinterpret_cast<const VkVideoEncodeCapabilitiesKHR *>(
+                                        find_caps_struct(capabilities, VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR));
+                                    if (caps != nullptr) {
+                                        supported =
+                                            supported &&
+                                            ((caps->flags & VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR) != 0);
+                                    } else {
+                                        supported = false;
+                                    }
+                                } else {
+                                    supported = false;
+                                }
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                if (format_properties_chain != nullptr) {
+                                    if (gpu.CheckPhysicalDeviceExtensionIncluded(
+                                            VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                        format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.sType =
+                                            VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR;
+                                        format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext = nullptr;
+                                        *ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR;
+                                        ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext;
+                                    }
+                                }
+                                if (format_properties_chain != nullptr) {
+                                    if (gpu.CheckPhysicalDeviceExtensionIncluded(
+                                            VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                        format_properties_chain->VideoFormatH265QuantizationMapPropertiesKHR.sType =
+                                            VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR;
+                                        format_properties_chain->VideoFormatH265QuantizationMapPropertiesKHR.pNext = nullptr;
+                                        *ppnext = &format_properties_chain->VideoFormatH265QuantizationMapPropertiesKHR;
+                                        ppnext = &format_properties_chain->VideoFormatH265QuantizationMapPropertiesKHR.pNext;
+                                    }
+                                }
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Emphasis Map",
+                            VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) {
+                                    auto caps = reinterpret_cast<const VkVideoEncodeCapabilitiesKHR *>(
+                                        find_caps_struct(capabilities, VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR));
+                                    if (caps != nullptr) {
+                                        supported =
+                                            supported && ((caps->flags & VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR) != 0);
+                                    } else {
+                                        supported = false;
+                                    }
+                                } else {
+                                    supported = false;
+                                }
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                if (format_properties_chain != nullptr) {
+                                    if (gpu.CheckPhysicalDeviceExtensionIncluded(
+                                            VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                        format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.sType =
+                                            VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR;
+                                        format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext = nullptr;
+                                        *ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR;
+                                        ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext;
+                                    }
+                                }
+                                if (format_properties_chain != nullptr) {
+                                    if (gpu.CheckPhysicalDeviceExtensionIncluded(
+                                            VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                        format_properties_chain->VideoFormatH265QuantizationMapPropertiesKHR.sType =
+                                            VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR;
+                                        format_properties_chain->VideoFormatH265QuantizationMapPropertiesKHR.pNext = nullptr;
+                                        *ppnext = &format_properties_chain->VideoFormatH265QuantizationMapPropertiesKHR;
+                                        ppnext = &format_properties_chain->VideoFormatH265QuantizationMapPropertiesKHR.pNext;
+                                    }
+                                }
+                                return format_properties_chain;
+                            },
+                        },
+                    };
+
+                    add_profile(profile_base_name + " Main", profile_info, create_profile_info_chain, create_capabilities_chain,
+                                create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoEncodeH265ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H265_PROFILE_IDC_MAIN;
+                                });
+                    add_profile(profile_base_name + " Main 10", profile_info, create_profile_info_chain, create_capabilities_chain,
+                                create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoEncodeH265ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H265_PROFILE_IDC_MAIN_10;
+                                });
+                    add_profile(profile_base_name + " Main Still Picture", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoEncodeH265ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE;
+                                });
+                    add_profile(profile_base_name + " Format range extensions", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoEncodeH265ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS;
+                                });
+                    add_profile(profile_base_name + " Screen content coding extensions", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoEncodeH265ProfileInfoKHR.stdProfileIdc =
+                                        STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS;
+                                });
+                }
+            }
+        }
+    }
+
+    if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME)) {
+        const std::string codec_name = "AV1 Encode";
+
+        for (auto chroma_subsampling : chroma_subsampling_list) {
+            for (auto luma_bit_depth : bit_depth_list) {
+                for (auto chroma_bit_depth : bit_depth_list) {
+                    if (chroma_subsampling.value == VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR &&
+                        luma_bit_depth.value != chroma_bit_depth.value) {
+                        // Ignore the chroma bit depth dimension for monochrome
+                        continue;
+                    }
+
+                    std::string profile_base_name = codec_name + base_format(chroma_subsampling, luma_bit_depth, chroma_bit_depth);
+                    VkVideoProfileInfoKHR profile_info{VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR,
+                                                       nullptr,
+                                                       VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR,
+                                                       chroma_subsampling.value,
+                                                       luma_bit_depth.value,
+                                                       chroma_bit_depth.value};
+
+                    auto create_profile_info_chain = [&](const void **ppnext) -> std::unique_ptr<video_profile_info_chain> {
+                        auto profile_info_chain = std::make_unique<video_profile_info_chain>();
+                        if (profile_info_chain != nullptr) {
+                            profile_info_chain->VideoEncodeAV1ProfileInfoKHR.sType =
+                                VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR;
+                            profile_info_chain->VideoEncodeAV1ProfileInfoKHR.pNext = nullptr;
+                            *ppnext = &profile_info_chain->VideoEncodeAV1ProfileInfoKHR;
+                            ppnext = &profile_info_chain->VideoEncodeAV1ProfileInfoKHR.pNext;
+                        }
+                        return profile_info_chain;
+                    };
+
+                    auto create_capabilities_chain = [&](void **ppnext) -> std::unique_ptr<video_capabilities_chain> {
+                        auto capabilities_chain = std::make_unique<video_capabilities_chain>();
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeQuantizationMapCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeIntraRefreshCapabilitiesKHR.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE;
+                                capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE;
+                                ppnext = &capabilities_chain->VideoEncodeRgbConversionCapabilitiesVALVE.pNext;
+                            }
+                        }
+                        if (capabilities_chain != nullptr) {
+                            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME)) {
+                                capabilities_chain->VideoEncodeAV1CapabilitiesKHR.sType =
+                                    VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR;
+                                capabilities_chain->VideoEncodeAV1CapabilitiesKHR.pNext = nullptr;
+                                *ppnext = &capabilities_chain->VideoEncodeAV1CapabilitiesKHR;
+                                ppnext = &capabilities_chain->VideoEncodeAV1CapabilitiesKHR.pNext;
+                            }
+                        }
+                        return capabilities_chain;
+                    };
+
+                    const AppVideoProfile::CreateFormatPropertiesChainCbList create_format_properties_chain_list = {
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Encode Input",
+                            VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "DPB",
+                            VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Quantization Delta Map",
+                            VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) {
+                                    auto caps = reinterpret_cast<const VkVideoEncodeCapabilitiesKHR *>(
+                                        find_caps_struct(capabilities, VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR));
+                                    if (caps != nullptr) {
+                                        supported =
+                                            supported &&
+                                            ((caps->flags & VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR) != 0);
+                                    } else {
+                                        supported = false;
+                                    }
+                                } else {
+                                    supported = false;
+                                }
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                if (format_properties_chain != nullptr) {
+                                    if (gpu.CheckPhysicalDeviceExtensionIncluded(
+                                            VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                        format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.sType =
+                                            VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR;
+                                        format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext = nullptr;
+                                        *ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR;
+                                        ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext;
+                                    }
+                                }
+                                if (format_properties_chain != nullptr) {
+                                    if (gpu.CheckPhysicalDeviceExtensionIncluded(
+                                            VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                        format_properties_chain->VideoFormatAV1QuantizationMapPropertiesKHR.sType =
+                                            VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR;
+                                        format_properties_chain->VideoFormatAV1QuantizationMapPropertiesKHR.pNext = nullptr;
+                                        *ppnext = &format_properties_chain->VideoFormatAV1QuantizationMapPropertiesKHR;
+                                        ppnext = &format_properties_chain->VideoFormatAV1QuantizationMapPropertiesKHR.pNext;
+                                    }
+                                }
+                                return format_properties_chain;
+                            },
+                        },
+                        AppVideoProfile::CreateFormatPropertiesChainCb{
+                            "Emphasis Map",
+                            VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR,
+                            [&](const VkVideoCapabilitiesKHR &capabilities) -> bool {
+                                bool supported = true;
+                                if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME)) {
+                                    auto caps = reinterpret_cast<const VkVideoEncodeCapabilitiesKHR *>(
+                                        find_caps_struct(capabilities, VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR));
+                                    if (caps != nullptr) {
+                                        supported =
+                                            supported && ((caps->flags & VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR) != 0);
+                                    } else {
+                                        supported = false;
+                                    }
+                                } else {
+                                    supported = false;
+                                }
+                                return supported;
+                            },
+                            [&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {
+                                auto format_properties_chain = std::make_unique<video_format_properties_chain>();
+                                if (format_properties_chain != nullptr) {
+                                    if (gpu.CheckPhysicalDeviceExtensionIncluded(
+                                            VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                        format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.sType =
+                                            VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR;
+                                        format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext = nullptr;
+                                        *ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR;
+                                        ppnext = &format_properties_chain->VideoFormatQuantizationMapPropertiesKHR.pNext;
+                                    }
+                                }
+                                if (format_properties_chain != nullptr) {
+                                    if (gpu.CheckPhysicalDeviceExtensionIncluded(
+                                            VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME)) {
+                                        format_properties_chain->VideoFormatAV1QuantizationMapPropertiesKHR.sType =
+                                            VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR;
+                                        format_properties_chain->VideoFormatAV1QuantizationMapPropertiesKHR.pNext = nullptr;
+                                        *ppnext = &format_properties_chain->VideoFormatAV1QuantizationMapPropertiesKHR;
+                                        ppnext = &format_properties_chain->VideoFormatAV1QuantizationMapPropertiesKHR.pNext;
+                                    }
+                                }
+                                return format_properties_chain;
+                            },
+                        },
+                    };
+
+                    add_profile(profile_base_name + " Main", profile_info, create_profile_info_chain, create_capabilities_chain,
+                                create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoEncodeAV1ProfileInfoKHR.stdProfile =
+                                        STD_VIDEO_AV1_PROFILE_MAIN;
+                                });
+                    add_profile(profile_base_name + " High", profile_info, create_profile_info_chain, create_capabilities_chain,
+                                create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoEncodeAV1ProfileInfoKHR.stdProfile =
+                                        STD_VIDEO_AV1_PROFILE_HIGH;
+                                });
+                    add_profile(profile_base_name + " Professional", profile_info, create_profile_info_chain,
+                                create_capabilities_chain, create_format_properties_chain_list, [](AppVideoProfile &profile) {
+                                    profile.profile_info_chain->VideoEncodeAV1ProfileInfoKHR.stdProfile =
+                                        STD_VIDEO_AV1_PROFILE_PROFESSIONAL;
+                                });
+                }
+            }
+        }
+    }
+    return result;
+}
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/project.pbxproj b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/project.pbxproj
new file mode 100644
index 00000000..41ab580a
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/project.pbxproj
@@ -0,0 +1,411 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 52;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		A06CCB40258D04F700B0A7DA /* vulkaninfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A06CCB3F258D04F700B0A7DA /* vulkaninfo.cpp */; };
+		A06CCB44258D0BE300B0A7DA /* MoltenVK.xcframework in Frameworks */ = {isa = PBXBuildFile; fileRef = A06CCB43258D0BE300B0A7DA /* MoltenVK.xcframework */; };
+		A07BD431255B45E000B79448 /* AppDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = A07BD430255B45E000B79448 /* AppDelegate.m */; };
+		A07BD434255B45E000B79448 /* SceneDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = A07BD433255B45E000B79448 /* SceneDelegate.m */; };
+		A07BD437255B45E000B79448 /* ViewController.m in Sources */ = {isa = PBXBuildFile; fileRef = A07BD436255B45E000B79448 /* ViewController.m */; };
+		A07BD43A255B45E100B79448 /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = A07BD438255B45E100B79448 /* Main.storyboard */; };
+		A07BD43C255B45E200B79448 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = A07BD43B255B45E200B79448 /* Assets.xcassets */; };
+		A07BD43F255B45E200B79448 /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = A07BD43D255B45E200B79448 /* LaunchScreen.storyboard */; };
+		A07BD442255B45E200B79448 /* main.mm in Sources */ = {isa = PBXBuildFile; fileRef = A07BD441255B45E200B79448 /* main.mm */; };
+		A07BD48D255B4DEE00B79448 /* metal_iosview.m in Sources */ = {isa = PBXBuildFile; fileRef = A07BD48C255B4DEE00B79448 /* metal_iosview.m */; };
+		A07BD4A5255C914A00B79448 /* WebKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A07BD4A4255C914A00B79448 /* WebKit.framework */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXFileReference section */
+		A06CCB3F258D04F700B0A7DA /* vulkaninfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = vulkaninfo.cpp; path = ../vulkaninfo.cpp; sourceTree = "<group>"; };
+		A06CCB43258D0BE300B0A7DA /* MoltenVK.xcframework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcframework; name = MoltenVK.xcframework; path = ../../../../VulkanSDK/MoltenVK/MoltenVK.xcframework; sourceTree = "<group>"; };
+		A07BD42C255B45E000B79448 /* vulkaninfo.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = vulkaninfo.app; sourceTree = BUILT_PRODUCTS_DIR; };
+		A07BD42F255B45E000B79448 /* AppDelegate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AppDelegate.h; sourceTree = "<group>"; };
+		A07BD430255B45E000B79448 /* AppDelegate.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = AppDelegate.m; sourceTree = "<group>"; };
+		A07BD432255B45E000B79448 /* SceneDelegate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SceneDelegate.h; sourceTree = "<group>"; };
+		A07BD433255B45E000B79448 /* SceneDelegate.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = SceneDelegate.m; sourceTree = "<group>"; };
+		A07BD435255B45E000B79448 /* ViewController.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ViewController.h; sourceTree = "<group>"; };
+		A07BD436255B45E000B79448 /* ViewController.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = ViewController.m; sourceTree = "<group>"; };
+		A07BD439255B45E100B79448 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/Main.storyboard; sourceTree = "<group>"; };
+		A07BD43B255B45E200B79448 /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = "<group>"; };
+		A07BD43E255B45E200B79448 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = "<group>"; };
+		A07BD440255B45E200B79448 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
+		A07BD441255B45E200B79448 /* main.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = main.mm; sourceTree = "<group>"; };
+		A07BD48C255B4DEE00B79448 /* metal_iosview.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = metal_iosview.m; sourceTree = "<group>"; };
+		A07BD48F255B4DF900B79448 /* metal_iosview.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = metal_iosview.h; sourceTree = "<group>"; };
+		A07BD4A4255C914A00B79448 /* WebKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = WebKit.framework; path = System/Library/Frameworks/WebKit.framework; sourceTree = SDKROOT; };
+		A0F9358C2575C05A00CFA527 /* vulkaninfo.entitlements */ = {isa = PBXFileReference; lastKnownFileType = text.plist.entitlements; path = vulkaninfo.entitlements; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		A07BD429255B45E000B79448 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				A06CCB44258D0BE300B0A7DA /* MoltenVK.xcframework in Frameworks */,
+				A07BD4A5255C914A00B79448 /* WebKit.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		A06CCB3E258D04E200B0A7DA /* Shared */ = {
+			isa = PBXGroup;
+			children = (
+				A06CCB3F258D04F700B0A7DA /* vulkaninfo.cpp */,
+			);
+			name = Shared;
+			sourceTree = "<group>";
+		};
+		A07BD423255B45E000B79448 = {
+			isa = PBXGroup;
+			children = (
+				A06CCB3E258D04E200B0A7DA /* Shared */,
+				A07BD473255B48AB00B79448 /* Frameworks */,
+				A07BD42E255B45E000B79448 /* vulkaninfo */,
+				A07BD42D255B45E000B79448 /* Products */,
+			);
+			sourceTree = "<group>";
+		};
+		A07BD42D255B45E000B79448 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				A07BD42C255B45E000B79448 /* vulkaninfo.app */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		A07BD42E255B45E000B79448 /* vulkaninfo */ = {
+			isa = PBXGroup;
+			children = (
+				A0F9358C2575C05A00CFA527 /* vulkaninfo.entitlements */,
+				A07BD48F255B4DF900B79448 /* metal_iosview.h */,
+				A07BD48C255B4DEE00B79448 /* metal_iosview.m */,
+				A07BD42F255B45E000B79448 /* AppDelegate.h */,
+				A07BD430255B45E000B79448 /* AppDelegate.m */,
+				A07BD432255B45E000B79448 /* SceneDelegate.h */,
+				A07BD433255B45E000B79448 /* SceneDelegate.m */,
+				A07BD435255B45E000B79448 /* ViewController.h */,
+				A07BD436255B45E000B79448 /* ViewController.m */,
+				A07BD438255B45E100B79448 /* Main.storyboard */,
+				A07BD43B255B45E200B79448 /* Assets.xcassets */,
+				A07BD43D255B45E200B79448 /* LaunchScreen.storyboard */,
+				A07BD440255B45E200B79448 /* Info.plist */,
+				A07BD441255B45E200B79448 /* main.mm */,
+			);
+			path = vulkaninfo;
+			sourceTree = "<group>";
+		};
+		A07BD473255B48AB00B79448 /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				A06CCB43258D0BE300B0A7DA /* MoltenVK.xcframework */,
+				A07BD4A4255C914A00B79448 /* WebKit.framework */,
+			);
+			path = Frameworks;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		A07BD42B255B45E000B79448 /* vulkaninfo */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = A07BD445255B45E200B79448 /* Build configuration list for PBXNativeTarget "vulkaninfo" */;
+			buildPhases = (
+				A07BD428255B45E000B79448 /* Sources */,
+				A07BD429255B45E000B79448 /* Frameworks */,
+				A07BD42A255B45E000B79448 /* Resources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = vulkaninfo;
+			productName = vulkaninfo;
+			productReference = A07BD42C255B45E000B79448 /* vulkaninfo.app */;
+			productType = "com.apple.product-type.application";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		A07BD424255B45E000B79448 /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastUpgradeCheck = 1210;
+				TargetAttributes = {
+					A07BD42B255B45E000B79448 = {
+						CreatedOnToolsVersion = 12.1;
+					};
+				};
+			};
+			buildConfigurationList = A07BD427255B45E000B79448 /* Build configuration list for PBXProject "vulkaninfo" */;
+			compatibilityVersion = "Xcode 9.3";
+			developmentRegion = en;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+				Base,
+			);
+			mainGroup = A07BD423255B45E000B79448;
+			productRefGroup = A07BD42D255B45E000B79448 /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				A07BD42B255B45E000B79448 /* vulkaninfo */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		A07BD42A255B45E000B79448 /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				A07BD43F255B45E200B79448 /* LaunchScreen.storyboard in Resources */,
+				A07BD43C255B45E200B79448 /* Assets.xcassets in Resources */,
+				A07BD43A255B45E100B79448 /* Main.storyboard in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		A07BD428255B45E000B79448 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				A07BD437255B45E000B79448 /* ViewController.m in Sources */,
+				A07BD431255B45E000B79448 /* AppDelegate.m in Sources */,
+				A06CCB40258D04F700B0A7DA /* vulkaninfo.cpp in Sources */,
+				A07BD442255B45E200B79448 /* main.mm in Sources */,
+				A07BD48D255B4DEE00B79448 /* metal_iosview.m in Sources */,
+				A07BD434255B45E000B79448 /* SceneDelegate.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXVariantGroup section */
+		A07BD438255B45E100B79448 /* Main.storyboard */ = {
+			isa = PBXVariantGroup;
+			children = (
+				A07BD439255B45E100B79448 /* Base */,
+			);
+			name = Main.storyboard;
+			sourceTree = "<group>";
+		};
+		A07BD43D255B45E200B79448 /* LaunchScreen.storyboard */ = {
+			isa = PBXVariantGroup;
+			children = (
+				A07BD43E255B45E200B79448 /* Base */,
+			);
+			name = LaunchScreen.storyboard;
+			sourceTree = "<group>";
+		};
+/* End PBXVariantGroup section */
+
+/* Begin XCBuildConfiguration section */
+		A07BD443255B45E200B79448 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = dwarf;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_TESTABILITY = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu11;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 14.1;
+				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
+				MTL_FAST_MATH = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				SDKROOT = iphoneos;
+			};
+			name = Debug;
+		};
+		A07BD444255B45E200B79448 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu11;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 14.1;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				MTL_FAST_MATH = YES;
+				SDKROOT = iphoneos;
+				VALIDATE_PRODUCT = YES;
+			};
+			name = Release;
+		};
+		A07BD446255B45E200B79448 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
+				CODE_SIGN_ENTITLEMENTS = vulkaninfo/vulkaninfo.entitlements;
+				CODE_SIGN_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = 5;
+				DEVELOPMENT_TEAM = 4777T3625D;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					VK_USE_PLATFORM_IOS_MVK,
+					VK_ENABLE_BETA_EXTENSIONS,
+				);
+				HEADER_SEARCH_PATHS = (
+					"\"$(SRCROOT)/../../build/Vulkan-Headers/include\"",
+					"\"$(SRCROOT)/../generated\"",
+					"\"$(SRCROOT)/..\"",
+					"\"$(SRCROOT)/vulkaninfo\"",
+				);
+				INFOPLIST_FILE = vulkaninfo/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				PRODUCT_BUNDLE_IDENTIFIER = com.lunarg.vulkaninfo;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SUPPORTS_MACCATALYST = YES;
+				TARGETED_DEVICE_FAMILY = "1,2";
+			};
+			name = Debug;
+		};
+		A07BD447255B45E200B79448 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
+				CODE_SIGN_ENTITLEMENTS = vulkaninfo/vulkaninfo.entitlements;
+				CODE_SIGN_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = 5;
+				DEVELOPMENT_TEAM = 4777T3625D;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					VK_USE_PLATFORM_IOS_MVK,
+					VK_ENABLE_BETA_EXTENSIONS,
+				);
+				HEADER_SEARCH_PATHS = (
+					"\"$(SRCROOT)/../../build/Vulkan-Headers/include\"",
+					"\"$(SRCROOT)/../generated\"",
+					"\"$(SRCROOT)/..\"",
+					"\"$(SRCROOT)/vulkaninfo\"",
+				);
+				INFOPLIST_FILE = vulkaninfo/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				PRODUCT_BUNDLE_IDENTIFIER = com.lunarg.vulkaninfo;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SUPPORTS_MACCATALYST = YES;
+				TARGETED_DEVICE_FAMILY = "1,2";
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		A07BD427255B45E000B79448 /* Build configuration list for PBXProject "vulkaninfo" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				A07BD443255B45E200B79448 /* Debug */,
+				A07BD444255B45E200B79448 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		A07BD445255B45E200B79448 /* Build configuration list for PBXNativeTarget "vulkaninfo" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				A07BD446255B45E200B79448 /* Debug */,
+				A07BD447255B45E200B79448 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = A07BD424255B45E000B79448 /* Project object */;
+}
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/project.xcworkspace/contents.xcworkspacedata
new file mode 100644
index 00000000..919434a6
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/project.xcworkspace/contents.xcworkspacedata
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "self:">
+   </FileRef>
+</Workspace>
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist
new file mode 100644
index 00000000..18d98100
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/project.xcworkspace/xcuserdata/lunarg.xcuserdatad/UserInterfaceState.xcuserstate b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/project.xcworkspace/xcuserdata/lunarg.xcuserdatad/UserInterfaceState.xcuserstate
new file mode 100644
index 00000000..dceb7e8c
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/project.xcworkspace/xcuserdata/lunarg.xcuserdatad/UserInterfaceState.xcuserstate
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/xcuserdata/lunarg.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/xcuserdata/lunarg.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist
new file mode 100644
index 00000000..5f774687
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/xcuserdata/lunarg.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist
@@ -0,0 +1,72 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Bucket
+   uuid = "CD03A52F-70EE-4CA8-8A04-AA37042731C8"
+   type = "1"
+   version = "2.0">
+   <Breakpoints>
+      <BreakpointProxy
+         BreakpointExtensionID = "Xcode.Breakpoint.FileBreakpoint">
+         <BreakpointContent
+            uuid = "0A318E23-A354-4504-B62D-377DC59080FC"
+            shouldBeEnabled = "No"
+            ignoreCount = "0"
+            continueAfterRunningActions = "No"
+            filePath = "../vulkaninfo.cpp"
+            startingColumnNumber = "9223372036854775807"
+            endingColumnNumber = "9223372036854775807"
+            startingLineNumber = "969"
+            endingLineNumber = "969"
+            landmarkName = "vulkanInfoMain(argc, argv)"
+            landmarkType = "9">
+         </BreakpointContent>
+      </BreakpointProxy>
+      <BreakpointProxy
+         BreakpointExtensionID = "Xcode.Breakpoint.FileBreakpoint">
+         <BreakpointContent
+            uuid = "2D991475-1A1D-4A97-A2CB-F3FBBA80BC4E"
+            shouldBeEnabled = "No"
+            ignoreCount = "0"
+            continueAfterRunningActions = "No"
+            filePath = "vulkaninfo/ViewController.m"
+            startingColumnNumber = "9223372036854775807"
+            endingColumnNumber = "9223372036854775807"
+            startingLineNumber = "39"
+            endingLineNumber = "39"
+            landmarkName = "-viewDidLoad"
+            landmarkType = "7">
+         </BreakpointContent>
+      </BreakpointProxy>
+      <BreakpointProxy
+         BreakpointExtensionID = "Xcode.Breakpoint.FileBreakpoint">
+         <BreakpointContent
+            uuid = "28380D7E-73BC-4B38-837F-7CCA9B35B00B"
+            shouldBeEnabled = "No"
+            ignoreCount = "0"
+            continueAfterRunningActions = "No"
+            filePath = "../outputprinter.h"
+            startingColumnNumber = "9223372036854775807"
+            endingColumnNumber = "9223372036854775807"
+            startingLineNumber = "306"
+            endingLineNumber = "306"
+            landmarkName = "ObjectStart(object_name)"
+            landmarkType = "7">
+         </BreakpointContent>
+      </BreakpointProxy>
+      <BreakpointProxy
+         BreakpointExtensionID = "Xcode.Breakpoint.FileBreakpoint">
+         <BreakpointContent
+            uuid = "B192D664-BFF2-4B2B-820F-815D8B2EFDAB"
+            shouldBeEnabled = "No"
+            ignoreCount = "0"
+            continueAfterRunningActions = "No"
+            filePath = "../outputprinter.h"
+            startingColumnNumber = "9223372036854775807"
+            endingColumnNumber = "9223372036854775807"
+            startingLineNumber = "406"
+            endingLineNumber = "406"
+            landmarkName = "ArrayStart(array_name)"
+            landmarkType = "7">
+         </BreakpointContent>
+      </BreakpointProxy>
+   </Breakpoints>
+</Bucket>
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/xcuserdata/lunarg.xcuserdatad/xcschemes/xcschememanagement.plist b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/xcuserdata/lunarg.xcuserdatad/xcschemes/xcschememanagement.plist
new file mode 100644
index 00000000..13496336
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo.xcodeproj/xcuserdata/lunarg.xcuserdatad/xcschemes/xcschememanagement.plist
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>SchemeUserState</key>
+	<dict>
+		<key>vulkaninfo.xcscheme_^#shared#^_</key>
+		<dict>
+			<key>orderHint</key>
+			<integer>0</integer>
+		</dict>
+	</dict>
+</dict>
+</plist>
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/AppDelegate.h b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/AppDelegate.h
new file mode 100644
index 00000000..69d01817
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/AppDelegate.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2020 The Khronos Group Inc.
+ * Copyright (c) 2020 Valve Corporation
+ * Copyright (c) 2020 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Richard Wright <richard@lunarg.com>
+ */
+
+#import <UIKit/UIKit.h>
+
+@interface AppDelegate : UIResponder <UIApplicationDelegate>
+
+@end
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/AppDelegate.m b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/AppDelegate.m
new file mode 100644
index 00000000..e8c0e3f4
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/AppDelegate.m
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2020 The Khronos Group Inc.
+ * Copyright (c) 2020 Valve Corporation
+ * Copyright (c) 2020 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Richard Wright <richard@lunarg.com>
+ */
+
+#import "AppDelegate.h"
+
+@interface AppDelegate ()
+
+@end
+
+@implementation AppDelegate
+
+- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
+    // Override point for customization after application launch.
+    return YES;
+}
+
+#pragma mark - UISceneSession lifecycle
+
+- (UISceneConfiguration *)application:(UIApplication *)application
+    configurationForConnectingSceneSession:(UISceneSession *)connectingSceneSession
+                                   options:(UISceneConnectionOptions *)options {
+    // Called when a new scene session is being created.
+    // Use this method to select a configuration to create the new scene with.
+    return [[UISceneConfiguration alloc] initWithName:@"Default Configuration" sessionRole:connectingSceneSession.role];
+}
+
+- (void)application:(UIApplication *)application didDiscardSceneSessions:(NSSet<UISceneSession *> *)sceneSessions {
+    // Called when the user discards a scene session.
+    // If any sessions were discarded while the application was not running, this will be called shortly after
+    // application:didFinishLaunchingWithOptions. Use this method to release any resources that were specific to the discarded
+    // scenes, as they will not return.
+}
+
+@end
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AccentColor.colorset/Contents.json b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AccentColor.colorset/Contents.json
new file mode 100644
index 00000000..eb878970
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AccentColor.colorset/Contents.json
@@ -0,0 +1,11 @@
+{
+  "colors" : [
+    {
+      "idiom" : "universal"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/Contents.json b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/Contents.json
new file mode 100644
index 00000000..efcf4234
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/Contents.json
@@ -0,0 +1,103 @@
+{
+  "images" : [
+    {
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "20x20"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "20x20"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "29x29"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "29x29"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "40x40"
+    },
+    {
+      "filename" : "VulkanLogo120-1.png",
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "40x40"
+    },
+    {
+      "filename" : "VulkanLogo120.png",
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "60x60"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "60x60"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "20x20"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "20x20"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "29x29"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "29x29"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "40x40"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "40x40"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "76x76"
+    },
+    {
+      "filename" : "VulkanLogo152.png",
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "76x76"
+    },
+    {
+      "filename" : "VulkanLogo167.png",
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "83.5x83.5"
+    },
+    {
+      "filename" : "VulkanAppLogo1024.png",
+      "idiom" : "ios-marketing",
+      "scale" : "1x",
+      "size" : "1024x1024"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanAppLogo1024.png b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanAppLogo1024.png
new file mode 100644
index 00000000..3c8f2282
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanAppLogo1024.png
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanLogo120-1.png b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanLogo120-1.png
new file mode 100644
index 00000000..04126379
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanLogo120-1.png
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanLogo120.png b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanLogo120.png
new file mode 100644
index 00000000..04126379
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanLogo120.png
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanLogo152.png b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanLogo152.png
new file mode 100644
index 00000000..23e503d2
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanLogo152.png
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanLogo167.png b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanLogo167.png
new file mode 100644
index 00000000..1545d57b
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/AppIcon.appiconset/VulkanLogo167.png
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/Contents.json b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/Contents.json
new file mode 100644
index 00000000..73c00596
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Assets.xcassets/Contents.json
@@ -0,0 +1,6 @@
+{
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Base.lproj/LaunchScreen.storyboard b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Base.lproj/LaunchScreen.storyboard
new file mode 100644
index 00000000..865e9329
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Base.lproj/LaunchScreen.storyboard
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="13122.16" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" useTraitCollections="YES" useSafeAreas="YES" colorMatched="YES" initialViewController="01J-lp-oVM">
+    <dependencies>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="13104.12"/>
+        <capability name="Safe area layout guides" minToolsVersion="9.0"/>
+        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
+    </dependencies>
+    <scenes>
+        <!--View Controller-->
+        <scene sceneID="EHf-IW-A2E">
+            <objects>
+                <viewController id="01J-lp-oVM" sceneMemberID="viewController">
+                    <view key="view" contentMode="scaleToFill" id="Ze5-6b-2t3">
+                        <rect key="frame" x="0.0" y="0.0" width="375" height="667"/>
+                        <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                        <color key="backgroundColor" xcode11CocoaTouchSystemColor="systemBackgroundColor" cocoaTouchSystemColor="whiteColor"/>
+                        <viewLayoutGuide key="safeArea" id="6Tk-OE-BBY"/>
+                    </view>
+                </viewController>
+                <placeholder placeholderIdentifier="IBFirstResponder" id="iYj-Kq-Ea1" userLabel="First Responder" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="53" y="375"/>
+        </scene>
+    </scenes>
+</document>
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Base.lproj/Main.storyboard b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Base.lproj/Main.storyboard
new file mode 100644
index 00000000..876d52ae
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Base.lproj/Main.storyboard
@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="17506" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" useTraitCollections="YES" useSafeAreas="YES" colorMatched="YES" initialViewController="BYZ-38-t0r">
+    <device id="retina6_1" orientation="portrait" appearance="light"/>
+    <dependencies>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="17505"/>
+        <capability name="Safe area layout guides" minToolsVersion="9.0"/>
+        <capability name="System colors in document resources" minToolsVersion="11.0"/>
+        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
+    </dependencies>
+    <scenes>
+        <!--View Controller-->
+        <scene sceneID="tne-QT-ifu">
+            <objects>
+                <viewController id="BYZ-38-t0r" customClass="ViewController" sceneMemberID="viewController">
+                    <view key="view" contentMode="scaleToFill" id="8bC-Xf-vdC">
+                        <rect key="frame" x="0.0" y="0.0" width="414" height="896"/>
+                        <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                        <subviews>
+                            <wkWebView contentMode="scaleToFill" fixedFrame="YES" translatesAutoresizingMaskIntoConstraints="NO" id="mvS-oO-lQz">
+                                <rect key="frame" x="0.0" y="34" width="414" height="820"/>
+                                <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                                <color key="backgroundColor" red="0.36078431370000003" green="0.38823529410000002" blue="0.4039215686" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
+                                <wkWebViewConfiguration key="configuration">
+                                    <audiovisualMediaTypes key="mediaTypesRequiringUserActionForPlayback" none="YES"/>
+                                    <wkPreferences key="preferences"/>
+                                </wkWebViewConfiguration>
+                            </wkWebView>
+                        </subviews>
+                        <viewLayoutGuide key="safeArea" id="6Tk-OE-BBY"/>
+                        <color key="backgroundColor" systemColor="systemBackgroundColor"/>
+                    </view>
+                    <connections>
+                        <outlet property="webView" destination="mvS-oO-lQz" id="Hyq-NC-6lo"/>
+                    </connections>
+                </viewController>
+                <placeholder placeholderIdentifier="IBFirstResponder" id="dkx-z0-nzr" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="13.043478260869566" y="79.6875"/>
+        </scene>
+    </scenes>
+    <resources>
+        <systemColor name="systemBackgroundColor">
+            <color white="1" alpha="1" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+        </systemColor>
+    </resources>
+</document>
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Info.plist b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Info.plist
new file mode 100644
index 00000000..2d3a4b00
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/Info.plist
@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleVersion</key>
+	<string>$(CURRENT_PROJECT_VERSION)</string>
+	<key>LSApplicationCategoryType</key>
+	<string></string>
+	<key>LSRequiresIPhoneOS</key>
+	<false/>
+	<key>UIApplicationSceneManifest</key>
+	<dict>
+		<key>UIApplicationSupportsMultipleScenes</key>
+		<false/>
+		<key>UISceneConfigurations</key>
+		<dict>
+			<key>UIWindowSceneSessionRoleApplication</key>
+			<array>
+				<dict>
+					<key>UISceneConfigurationName</key>
+					<string>Default Configuration</string>
+					<key>UISceneDelegateClassName</key>
+					<string>SceneDelegate</string>
+					<key>UISceneStoryboardFile</key>
+					<string>Main</string>
+				</dict>
+			</array>
+		</dict>
+	</dict>
+	<key>UIApplicationSupportsIndirectInputEvents</key>
+	<true/>
+	<key>UIFileSharingEnabled</key>
+	<true/>
+	<key>UILaunchStoryboardName</key>
+	<string>LaunchScreen</string>
+	<key>UIMainStoryboardFile</key>
+	<string>Main</string>
+	<key>UIRequiredDeviceCapabilities</key>
+	<array>
+		<string>armv7</string>
+	</array>
+	<key>UISupportedInterfaceOrientations</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+		<string>UIInterfaceOrientationPortraitUpsideDown</string>
+	</array>
+	<key>UISupportedInterfaceOrientations~ipad</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationPortraitUpsideDown</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+</dict>
+</plist>
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/SceneDelegate.h b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/SceneDelegate.h
new file mode 100644
index 00000000..39934557
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/SceneDelegate.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2020 The Khronos Group Inc.
+ * Copyright (c) 2020 Valve Corporation
+ * Copyright (c) 2020 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Richard Wright <richard@lunarg.com>
+ */
+
+#import <UIKit/UIKit.h>
+
+@interface SceneDelegate : UIResponder <UIWindowSceneDelegate>
+
+@property(strong, nonatomic) UIWindow* window;
+
+@end
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/SceneDelegate.m b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/SceneDelegate.m
new file mode 100644
index 00000000..8188b717
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/SceneDelegate.m
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2020 The Khronos Group Inc.
+ * Copyright (c) 2020 Valve Corporation
+ * Copyright (c) 2020 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Richard Wright <richard@lunarg.com>
+ */
+
+#import "SceneDelegate.h"
+
+@interface SceneDelegate ()
+
+@end
+
+@implementation SceneDelegate
+
+- (void)scene:(UIScene *)scene
+    willConnectToSession:(UISceneSession *)session
+                 options:(UISceneConnectionOptions *)connectionOptions {
+    // Use this method to optionally configure and attach the UIWindow `window` to the provided UIWindowScene `scene`.
+    // If using a storyboard, the `window` property will automatically be initialized and attached to the scene.
+    // This delegate does not imply the connecting scene or session are new (see
+    // `application:configurationForConnectingSceneSession` instead).
+}
+
+- (void)sceneDidDisconnect:(UIScene *)scene {
+    // Called as the scene is being released by the system.
+    // This occurs shortly after the scene enters the background, or when its session is discarded.
+    // Release any resources associated with this scene that can be re-created the next time the scene connects.
+    // The scene may re-connect later, as its session was not necessarily discarded (see `application:didDiscardSceneSessions`
+    // instead).
+}
+
+- (void)sceneDidBecomeActive:(UIScene *)scene {
+    // Called when the scene has moved from an inactive state to an active state.
+    // Use this method to restart any tasks that were paused (or not yet started) when the scene was inactive.
+}
+
+- (void)sceneWillResignActive:(UIScene *)scene {
+    // Called when the scene will move from an active state to an inactive state.
+    // This may occur due to temporary interruptions (ex. an incoming phone call).
+}
+
+- (void)sceneWillEnterForeground:(UIScene *)scene {
+    // Called as the scene transitions from the background to the foreground.
+    // Use this method to undo the changes made on entering the background.
+}
+
+- (void)sceneDidEnterBackground:(UIScene *)scene {
+    // Called as the scene transitions from the foreground to the background.
+    // Use this method to save data, release shared resources, and store enough scene-specific state information
+    // to restore the scene back to its current state.
+}
+
+@end
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/ViewController.h b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/ViewController.h
new file mode 100644
index 00000000..f897dc9a
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/ViewController.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2020 The Khronos Group Inc.
+ * Copyright (c) 2020 Valve Corporation
+ * Copyright (c) 2020 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Richard Wright <richard@lunarg.com>
+ */
+
+#import <UIKit/UIKit.h>
+#import <WebKit/WKWebView.h>
+
+@interface ViewController : UIViewController
+
+@property(weak, nonatomic) IBOutlet WKWebView *webView;
+
+@end
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/ViewController.m b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/ViewController.m
new file mode 100644
index 00000000..573c7da0
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/ViewController.m
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2020 The Khronos Group Inc.
+ * Copyright (c) 2020 Valve Corporation
+ * Copyright (c) 2020 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Richard Wright <richard@lunarg.com>
+ */
+
+#import "ViewController.h"
+
+@interface ViewController ()
+
+@end
+
+@implementation ViewController
+
+- (void)viewDidLoad {
+    [super viewDidLoad];
+
+    // Get the HTML version of the output and display it in a web view.
+    NSArray *docPath = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
+    NSString *myPath = [docPath objectAtIndex:0];
+    NSString *filePath = [myPath stringByAppendingPathComponent:@"/vulkaninfo.html"];
+
+    NSURL *url = [NSURL fileURLWithPath:filePath];
+    [webView loadFileURL:url allowingReadAccessToURL:url.URLByDeletingLastPathComponent];
+}
+
+@synthesize webView;
+
+@end
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/main.mm b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/main.mm
new file mode 100644
index 00000000..0643a490
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/main.mm
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2020 The Khronos Group Inc.
+ * Copyright (c) 2020 Valve Corporation
+ * Copyright (c) 2020 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Richard Wright <richard@lunarg.com>
+ */
+
+#import <UIKit/UIKit.h>
+#import "AppDelegate.h"
+
+int vulkanInfoMain(int argc, char **argv);
+
+int main(int argc, char *argv[]) {
+    // First thing we are going to "run" vulkaninfo to create the file output
+    // So that we don't have to touch the C++ desktop code, we'll set the current working directory
+    // to the shared documents folder where we are allowed to create and store files
+    NSArray *docPath = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
+    NSString *myPath = [docPath objectAtIndex:0];
+    chdir([myPath UTF8String]);
+
+    // HTML Version
+    const char *htmlArgs[2] = {"vulkaninfo", "--html"};
+    vulkanInfoMain(2, (char **)htmlArgs);
+
+    // JSON output
+    const char *jsonArgs[2] = {"vulkaninfo", "--json"};
+    vulkanInfoMain(2, (char **)jsonArgs);
+
+    const char *portArgs[2] = {"vulkaninfo", "--portability"};
+    vulkanInfoMain(2, (char **)portArgs);
+
+    NSString *appDelegateClassName;
+    @autoreleasepool {
+        // Setup code that might create autoreleased objects goes here.
+        appDelegateClassName = NSStringFromClass([AppDelegate class]);
+    }
+    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
+}
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/metal_iosview.h b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/metal_iosview.h
new file mode 100644
index 00000000..ebeacaf2
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/metal_iosview.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2018-2020 The Khronos Group Inc.
+ * Copyright (c) 2018-2020 Valve Corporation
+ * Copyright (c) 2018-2020 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Jeremy Kniager <jeremyk@lunarg.com>
+ * Author: Richard Wright <richard@lunarg.com>
+ */
+
+#ifndef metal_iosview_h
+#define metal_iosview_h
+
+void* CreateMetalView(uint32_t width, uint32_t height);
+
+void DestroyMetalView(void* view);
+
+void* GetCAMetalLayerFromMetalView(void* view);
+
+#endif /* metal_view_h */
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/metal_iosview.m b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/metal_iosview.m
new file mode 100644
index 00000000..df0d4f1f
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/metal_iosview.m
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2018-2020 The Khronos Group Inc.
+ * Copyright (c) 2018-2020 Valve Corporation
+ * Copyright (c) 2018-2020 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Jeremy Kniager <jeremyk@lunarg.com>
+ * Author: Richard Wright <richard@lunarg.com>
+ */
+
+#import <UIKit/UIKit.h>
+
+@interface NativeMetalView : UIView
+@end
+
+@implementation NativeMetalView
+- (id)init:(CGRect)frame {
+    self = [super initWithFrame:frame];
+    return self;
+}
+
++ (Class)layerClass {
+    return [CAMetalLayer class];
+}
+
+- (CALayer*)makeBackingLayer {
+    CALayer* layer = [self.class.layerClass layer];
+    // CGSize viewScale = [self convertSizeToBacking:CGSizeMake(1.0, 1.0)];
+    // layer.contentsScale = MIN(viewScale.width, viewScale.height);
+    return layer;
+}
+@end
+
+NativeMetalView* CreateMetalView(uint32_t width, uint32_t height) {
+    return [[NativeMetalView alloc] initWithFrame:CGRectMake(0, 0, width, height)];
+}
+
+// void DestroyMetalView(void* view) { [(NativeMetalView*)view dealloc]; }
+
+CAMetalLayer* GetCAMetalLayerFromMetalView(NativeMetalView* view) { return (CAMetalLayer*)view.layer; }
diff --git a/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/vulkaninfo.entitlements b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/vulkaninfo.entitlements
new file mode 100644
index 00000000..ee95ab7e
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/iOS/vulkaninfo/vulkaninfo.entitlements
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>com.apple.security.app-sandbox</key>
+	<true/>
+	<key>com.apple.security.network.client</key>
+	<true/>
+</dict>
+</plist>
diff --git a/tools/Vulkan-Tools/vulkaninfo/json_validation_process.md b/tools/Vulkan-Tools/vulkaninfo/json_validation_process.md
new file mode 100644
index 00000000..32df4f6f
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/json_validation_process.md
@@ -0,0 +1,24 @@
+# Validating [vulkaninfo](https://github.com/KhronosGroup/Vulkan-Tools/tree/main/vulkaninfo) JSON output
+
+The format of vulkaninfo's JSON output is designed to be used as input for the
+[Vulkan Profiles](https://github.com/KhronosGroup/Vulkan-Profiles)
+solution.
+
+The Vulkan Profiles JSON schema specifies exactly how the JSON must be structured.
+The schemas may be found at [here](https://schema.khronos.org/vulkan/).
+Select the latest schema that `vulkaninfo` was designed to be used with, or simply take the latest available schema.
+
+## Steps to validate JSON data against the Vulkan Profiles schema
+
+1. Generate the text to be tested using `vulkaninfo --json` which creates a `.json` file automatically.
+1. Download the [Vulkan Profiles schema](https://schema.khronos.org/vulkan/) to another file.
+1. For each of the on-line JSON validator tools listed below:
+   1. Paste the schema and and sample text into the `schema` and `data` fields.
+   1. Depending on the tool, it may validate automatically, or require clicking a `validate` button.
+   1. Ensure the tool reports no errors.
+
+## List of recommended JSON validator tools
+
+* https://www.jsonschemavalidator.net/
+* https://jsonschemalint.com/#/version/draft-04/markup/json
+* https://json-schema-validator.herokuapp.com/index.jsp
diff --git a/tools/Vulkan-Tools/vulkaninfo/macOS/vulkaninfo/metal_view.h b/tools/Vulkan-Tools/vulkaninfo/macOS/vulkaninfo/metal_view.h
new file mode 100644
index 00000000..31429d41
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/macOS/vulkaninfo/metal_view.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2018 The Khronos Group Inc.
+ * Copyright (c) 2018 Valve Corporation
+ * Copyright (c) 2018 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Jeremy Kniager <jeremyk@lunarg.com>
+ */
+
+#ifndef metal_view_h
+#define metal_view_h
+
+void* CreateMetalView(uint32_t width, uint32_t height);
+
+void DestroyMetalView(void* view);
+
+void* GetCAMetalLayerFromMetalView(void* view);
+
+#endif /* metal_view_h */
diff --git a/tools/Vulkan-Tools/vulkaninfo/macOS/vulkaninfo/metal_view.mm b/tools/Vulkan-Tools/vulkaninfo/macOS/vulkaninfo/metal_view.mm
new file mode 100644
index 00000000..90bff4c5
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/macOS/vulkaninfo/metal_view.mm
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2018 The Khronos Group Inc.
+ * Copyright (c) 2018 Valve Corporation
+ * Copyright (c) 2018 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Jeremy Kniager <jeremyk@lunarg.com>
+ */
+
+#import <AppKit/AppKit.h>
+#import <QuartzCore/QuartzCore.h>
+
+@interface NativeMetalView : NSView
+@end
+
+@implementation NativeMetalView
+- (id)initWithFrame:(NSRect)frame {
+    if (self = [super initWithFrame:frame]) {
+        self.wantsLayer = YES;
+    }
+    return self;
+}
+
++ (Class)layerClass {
+    return [CAMetalLayer class];
+}
+
+- (CALayer*)makeBackingLayer {
+    CALayer* layer = [self.class.layerClass layer];
+    CGSize viewScale = [self convertSizeToBacking:CGSizeMake(1.0, 1.0)];
+    layer.contentsScale = MIN(viewScale.width, viewScale.height);
+    return layer;
+}
+@end
+
+void* CreateMetalView(uint32_t width, uint32_t height) {
+    return [[NativeMetalView alloc] initWithFrame:NSMakeRect(0, 0, width, height)];
+}
+
+void DestroyMetalView(void* view) { [(NativeMetalView*)view dealloc]; }
+
+void* GetCAMetalLayerFromMetalView(void* view) { return ((NativeMetalView*)view).layer; }
diff --git a/tools/Vulkan-Tools/vulkaninfo/outputprinter.h b/tools/Vulkan-Tools/vulkaninfo/outputprinter.h
new file mode 100644
index 00000000..8255e928
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/outputprinter.h
@@ -0,0 +1,829 @@
+/*
+ * Copyright (c) 2019 The Khronos Group Inc.
+ * Copyright (c) 2019 Valve Corporation
+ * Copyright (c) 2019 LunarG, Inc.
+ * Copyright (c) 2023 RasterGrid Kft.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Charles Giessen <charles@lunarg.com>
+ *
+ */
+
+#pragma once
+
+#include <iomanip>
+#include <iostream>
+#include <ostream>
+#include <stack>
+#include <sstream>
+#include <string>
+
+#include <assert.h>
+
+#include "vulkaninfo.h"
+
+std::string insert_quotes(std::string s) { return "\"" + s + "\""; }
+
+std::string to_string(const std::array<uint8_t, 16> &uid) {
+    std::stringstream ss;
+    ss << std::hex << std::setfill('0');
+    for (int i = 0; i < 16; ++i) {
+        if (i == 4 || i == 6 || i == 8 || i == 10) ss << '-';
+        ss << std::setw(2) << static_cast<unsigned>(uid[i]);
+    }
+    return ss.str();
+}
+std::string to_string(const std::array<uint8_t, 8> &uid) {
+    std::stringstream ss;
+    ss << std::hex << std::setfill('0');
+    for (int i = 0; i < 8; ++i) {
+        if (i == 4) ss << '-';
+        ss << std::setw(2) << static_cast<unsigned>(uid[i]);
+    }
+    return ss.str();
+}
+
+std::ostream &operator<<(std::ostream &out, const VkConformanceVersion &v) {
+    return out << static_cast<unsigned>(v.major) << "." << static_cast<unsigned>(v.minor) << "."
+               << static_cast<unsigned>(v.subminor) << "." << static_cast<unsigned>(v.patch);
+}
+
+enum class OutputType { text, html, json, vkconfig_output };
+
+struct PrinterCreateDetails {
+    OutputType output_type = OutputType::text;
+    bool print_to_file = false;
+    std::string file_name = APP_SHORT_NAME ".txt";
+    std::string start_string = "";
+};
+
+class Printer {
+  public:
+    Printer(const PrinterCreateDetails &details, std::ostream &out, const APIVersion vulkan_version)
+        : output_type(details.output_type), out(out) {
+        StackNode node{};
+        node.is_first_item = false;
+        node.indents = 0;
+        switch (output_type) {
+            case (OutputType::text):
+                out << std::string(strlen(APP_UPPER_CASE_NAME), '=') << "\n";
+                out << APP_UPPER_CASE_NAME "\n";
+                out << std::string(strlen(APP_UPPER_CASE_NAME), '=') << "\n\n";
+                out << API_NAME " Instance Version: " << APIVersion(vulkan_version) << "\n\n\n";
+                break;
+            case (OutputType::html):
+                out << "<!doctype html>\n";
+                out << "<html lang='en'>\n";
+                out << "\t<head>\n";
+                out << "\t\t<title>" APP_SHORT_NAME "</title>\n";
+                out << "\t\t<style>\n";
+                out << "\t\thtml {\n";
+                out << "\t\t\tbackground-color: #0b1e48;\n";
+                out << "\t\t\tbackground-image: url(\"https://vulkan.lunarg.com/img/bg-starfield.jpg\");\n";
+                out << "\t\t\tbackground-position: center;\n";
+                out << "\t\t\t-webkit-background-size: cover;\n";
+                out << "\t\t\t-moz-background-size: cover;\n";
+                out << "\t\t\t-o-background-size: cover;\n";
+                out << "\t\t\tbackground-size: cover;\n";
+                out << "\t\t\tbackground-attachment: fixed;\n";
+                out << "\t\t\tbackground-repeat: no-repeat;\n";
+                out << "\t\t\theight: 100%;\n";
+                out << "\t\t}\n";
+                out << "\t\t#header {\n";
+                out << "\t\t\tz-index: -1;\n";
+                out << "\t\t}\n";
+                out << "\t\t#header>img {\n";
+                out << "\t\t\tposition: absolute;\n";
+                out << "\t\t\twidth: 160px;\n";
+                out << "\t\t\tmargin-left: -280px;\n";
+                out << "\t\t\ttop: -10px;\n";
+                out << "\t\t\tleft: 50%;\n";
+                out << "\t\t}\n";
+                out << "\t\t#header>h1 {\n";
+                out << "\t\t\tfont-family: Arial, \"Helvetica Neue\", Helvetica, sans-serif;\n";
+                out << "\t\t\tfont-size: 44px;\n";
+                out << "\t\t\tfont-weight: 200;\n";
+                out << "\t\t\ttext-shadow: 4px 4px 5px #000;\n";
+                out << "\t\t\tcolor: #eee;\n";
+                out << "\t\t\tposition: absolute;\n";
+                out << "\t\t\twidth: 400px;\n";
+                out << "\t\t\tmargin-left: -80px;\n";
+                out << "\t\t\ttop: 8px;\n";
+                out << "\t\t\tleft: 50%;\n";
+                out << "\t\t}\n";
+                out << "\t\tbody {\n";
+                out << "\t\t\tfont-family: Consolas, monaco, monospace;\n";
+                out << "\t\t\tfont-size: 14px;\n";
+                out << "\t\t\tline-height: 20px;\n";
+                out << "\t\t\tcolor: #eee;\n";
+                out << "\t\t\theight: 100%;\n";
+                out << "\t\t\tmargin: 0;\n";
+                out << "\t\t\toverflow: hidden;\n";
+                out << "\t\t}\n";
+                out << "\t\t#wrapper {\n";
+                out << "\t\t\tbackground-color: rgba(0, 0, 0, 0.7);\n";
+                out << "\t\t\tborder: 1px solid #446;\n";
+                out << "\t\t\tbox-shadow: 0px 0px 10px #000;\n";
+                out << "\t\t\tpadding: 8px 12px;\n\n";
+                out << "\t\t\tdisplay: inline-block;\n";
+                out << "\t\t\tposition: absolute;\n";
+                out << "\t\t\ttop: 80px;\n";
+                out << "\t\t\tbottom: 25px;\n";
+                out << "\t\t\tleft: 50px;\n";
+                out << "\t\t\tright: 50px;\n";
+                out << "\t\t\toverflow: auto;\n";
+                out << "\t\t}\n";
+                out << "\t\tdetails>details {\n";
+                out << "\t\t\tmargin-left: 22px;\n";
+                out << "\t\t}\n";
+                out << "\t\tdetails>summary:only-child::-webkit-details-marker {\n";
+                out << "\t\t\tdisplay: none;\n";
+                out << "\t\t}\n";
+                out << "\t\t.var, .type, .val {\n";
+                out << "\t\t\tdisplay: inline;\n";
+                out << "\t\t}\n";
+                out << "\t\t.var {\n";
+                out << "\t\t}\n";
+                out << "\t\t.type {\n";
+                out << "\t\t\tcolor: #acf;\n";
+                out << "\t\t\tmargin: 0 12px;\n";
+                out << "\t\t}\n";
+                out << "\t\t.val {\n";
+                out << "\t\t\tcolor: #afa;\n";
+                out << "\t\t\tbackground: #222;\n";
+                out << "\t\t\ttext-align: right;\n";
+                out << "\t\t}\n";
+                out << "\t\t</style>\n";
+                out << "\t</head>\n";
+                out << "\t<body>\n";
+                out << "\t\t<div id='header'>\n";
+                out << "\t\t\t<h1>" APP_SHORT_NAME "</h1>\n";
+                out << "\t\t</div>\n";
+                out << "\t\t<div id='wrapper'>\n";
+                out << "\t\t\t<details><summary>" API_NAME " Instance Version: <span class='val'>" << APIVersion(vulkan_version)
+                    << "</span></summary></details>\n\t\t\t<br />\n";
+                node.indents = 3;
+                break;
+            case (OutputType::json):
+            case (OutputType::vkconfig_output):
+                out << details.start_string;
+                node.indents = 1;
+                break;
+            default:
+                break;
+        }
+        object_stack.push(node);
+    }
+    ~Printer() {
+        switch (output_type) {
+            case (OutputType::text):
+                break;
+            case (OutputType::html):
+                out << "\t\t</div>\n";
+                out << "\t</body>\n";
+                out << "</html>\n";
+                break;
+            case (OutputType::json):
+            case (OutputType::vkconfig_output):
+                out << "\n}\n";
+                break;
+        }
+        assert(!object_stack.empty() && "mismatched number of ObjectStart/ObjectEnd or ArrayStart/ArrayEnd's");
+        object_stack.pop();
+        assert(object_stack.empty() && "indents must be zero at program end");
+    };
+
+    Printer(const Printer &) = delete;
+    const Printer &operator=(const Printer &) = delete;
+
+    OutputType Type() { return output_type; }
+
+    // When an error occurs, call this to create a valid output file. Needed for json/html
+    void FinishOutput() {
+        while (!object_stack.empty()) {
+            switch (output_type) {
+                case (OutputType::text):
+                    break;
+                case (OutputType::html):
+                    while (get_top().indents > 3) {
+                        out << "</details>\n";
+                    }
+                    break;
+                case (OutputType::json):
+                case (OutputType::vkconfig_output):
+                    out << "\n" << std::string(static_cast<size_t>(get_top().indents), '\t');
+                    if (get_top().is_array) {
+                        out << "]";
+                    } else {
+                        out << "}";
+                    }
+                    break;
+                default:
+                    break;
+            }
+            object_stack.pop();
+        }
+    }
+
+    // Custom Formatting
+    // use by prepending with p.SetXXX().ObjectStart/ArrayStart
+
+    Printer &SetHeader() {
+        get_top().set_next_header = true;
+        return *this;
+    }
+
+    Printer &SetSubHeader() {
+        get_top().set_next_subheader = true;
+        return *this;
+    }
+
+    Printer &SetOpenDetails() {
+        get_top().set_details_open = true;
+        return *this;
+    }
+
+    Printer &SetAlwaysOpenDetails(bool value = true) {
+        get_top().should_always_open = value;
+        return *this;
+    }
+
+    Printer &SetTitleAsType() {
+        get_top().set_object_name_as_type = true;
+        return *this;
+    }
+
+    Printer &SetAsType() {
+        get_top().set_as_type = true;
+        return *this;
+    }
+
+    Printer &SetIgnoreMinWidthInChild() {
+        get_top().ignore_min_width_parameter_in_child = true;
+        return *this;
+    }
+
+    Printer &SetMinKeyWidth(size_t min_key_width) {
+        get_top().min_key_width = min_key_width;
+        return *this;
+    }
+
+    Printer &SetElementIndex(int index) {
+        assert(index >= 0 && "cannot set element index to a negative value");
+        get_top().element_index = index;
+        return *this;
+    }
+    Printer &SetValueDescription(std::string str) {
+        value_description = str;
+        return *this;
+    }
+
+    void ObjectStart(std::string object_name, int32_t count_subobjects = -1) {
+        switch (output_type) {
+            case (OutputType::text): {
+                out << std::string(static_cast<size_t>(get_top().indents), '\t') << object_name;
+                if (!value_description.empty()) {
+                    out << " (" << value_description << ")";
+                    value_description = {};
+                }
+                if (get_top().element_index != -1) {
+                    out << "[" << get_top().element_index << "]";
+                }
+                out << ":";
+                if (count_subobjects >= 0) {
+                    out << " count = " << count_subobjects;
+                }
+                out << "\n";
+                size_t headersize = object_name.size() + 1;
+                if (count_subobjects >= 0) {
+                    headersize += 9 + std::to_string(count_subobjects).size();
+                }
+                if (get_top().element_index != -1) {
+                    headersize += 2 + std::to_string(get_top().element_index).size();
+                    get_top().element_index = -1;
+                }
+                PrintHeaderUnderlines(headersize);
+                break;
+            }
+            case (OutputType::html):
+                out << std::string(static_cast<size_t>(get_top().indents), '\t');
+                if (get_top().set_details_open || get_top().should_always_open) {
+                    out << "<details open>";
+                    get_top().set_details_open = false;
+                } else {
+                    out << "<details>";
+                }
+                out << "<summary>";
+                if (get_top().set_object_name_as_type) {
+                    out << "<span class='type'>" << object_name << "</span>";
+                    get_top().set_object_name_as_type = false;
+                } else {
+                    out << object_name;
+                }
+                if (!value_description.empty()) {
+                    out << " (" << value_description << ")";
+                    value_description = {};
+                }
+                if (get_top().element_index != -1) {
+                    out << "[<span class='val'>" << get_top().element_index << "</span>]";
+                    get_top().element_index = -1;
+                }
+                if (count_subobjects >= 0) {
+                    out << ": count = <span class='val'>" << std::to_string(count_subobjects) << "</span>";
+                }
+                out << "</summary>\n";
+                break;
+            case (OutputType::json):
+                if (!get_top().is_first_item) {
+                    out << ",\n";
+                } else {
+                    get_top().is_first_item = false;
+                }
+                out << std::string(static_cast<size_t>(get_top().indents), '\t');
+                // Objects with no name are elements in an array of objects
+                if (get_top().is_array || object_name == "" || get_top().element_index != -1) {
+                    out << "{\n";
+                    get_top().element_index = -1;
+                } else {
+                    out << "\"" << object_name << "\": {\n";
+                }
+                if (!value_description.empty()) {
+                    value_description = {};
+                }
+                break;
+            case (OutputType::vkconfig_output):
+                if (!get_top().is_first_item) {
+                    out << ",\n";
+                } else {
+                    get_top().is_first_item = false;
+                }
+                out << std::string(static_cast<size_t>(get_top().indents), '\t');
+
+                if (get_top().is_array && get_top().element_index != -1) {
+                    out << "\"" << object_name << "[" << get_top().element_index << "]\": ";
+                    get_top().element_index = -1;
+                } else if (!get_top().is_array) {
+                    out << "\"" << object_name << "\": ";
+                }
+                out << "{\n";
+                if (!value_description.empty()) {
+                    value_description = {};
+                }
+                break;
+            default:
+                break;
+        }
+        push_node(false);
+    }
+    void ObjectEnd() {
+        assert(get_top().is_array == false && "cannot call ObjectEnd while inside an Array");
+        object_stack.pop();
+        assert(get_top().indents >= 0 && "indents cannot go below zero");
+        switch (output_type) {
+            case (OutputType::text):
+
+                break;
+            case (OutputType::html):
+                out << std::string(static_cast<size_t>(get_top().indents), '\t') << "</details>\n";
+                break;
+            case (OutputType::json):
+            case (OutputType::vkconfig_output):
+                out << "\n" << std::string(static_cast<size_t>(get_top().indents), '\t') << "}";
+                break;
+            default:
+                break;
+        }
+    }
+    void ArrayStart(std::string array_name, size_t element_count = 0) {
+        switch (output_type) {
+            case (OutputType::text): {
+                out << std::string(static_cast<size_t>(get_top().indents), '\t') << array_name << ":";
+                size_t underline_count = array_name.size() + 1;
+                if (element_count > 0) {
+                    out << " count = " << element_count;
+                    underline_count += 9 + std::to_string(element_count).size();
+                }
+                out << "\n";
+                PrintHeaderUnderlines(underline_count);
+                break;
+            }
+            case (OutputType::html):
+                out << std::string(static_cast<size_t>(get_top().indents), '\t');
+                if (get_top().set_details_open || get_top().should_always_open) {
+                    out << "<details open>";
+                    get_top().set_details_open = false;
+                } else {
+                    out << "<details>";
+                }
+                out << "<summary>" << array_name;
+                if (element_count > 0) {
+                    out << ": count = <span class='val'>" << element_count << "</span>";
+                }
+                out << "</summary>\n";
+                break;
+            case (OutputType::json):
+            case (OutputType::vkconfig_output):
+                if (!get_top().is_first_item) {
+                    out << ",\n";
+                } else {
+                    get_top().is_first_item = false;
+                }
+                out << std::string(static_cast<size_t>(get_top().indents), '\t');
+                if (!get_top().is_array) {
+                    out << "\"" << array_name << "\": ";
+                }
+                out << "[\n";
+                break;
+            default:
+                break;
+        }
+        push_node(true);
+    }
+    void ArrayEnd() {
+        assert(get_top().is_array == true && "cannot call ArrayEnd while inside an Object");
+        object_stack.pop();
+        assert(get_top().indents >= 0 && "indents cannot go below zero");
+        switch (output_type) {
+            case (OutputType::text):
+                break;
+            case (OutputType::html):
+                out << std::string(static_cast<size_t>(get_top().indents), '\t') << "</details>\n";
+                break;
+            case (OutputType::json):
+            case (OutputType::vkconfig_output):
+                out << "\n" << std::string(static_cast<size_t>(get_top().indents), '\t') << "]";
+                break;
+            default:
+                break;
+        }
+    }
+
+    // For printing key-value pairs.
+    // value_description is for reference information and is displayed inside parenthesis after the value
+    template <typename T>
+    void PrintKeyValue(std::string key, T value) {
+        // If we are inside of an array, Print the value as an element
+        if (get_top().is_array) {
+            PrintElement(value);
+            return;
+        }
+
+        switch (output_type) {
+            case (OutputType::text):
+                out << std::string(static_cast<size_t>(get_top().indents), '\t') << key;
+                if (get_top().min_key_width > key.size() && !get_top().ignore_min_width_parameter) {
+                    out << std::string(get_top().min_key_width - key.size(), ' ');
+                }
+                out << " = " << value;
+                if (value_description != "") {
+                    out << " (" << value_description << ")";
+                    value_description = {};
+                }
+                out << "\n";
+                break;
+            case (OutputType::html):
+                out << std::string(static_cast<size_t>(get_top().indents), '\t') << "<details><summary>" << key;
+                if (get_top().min_key_width > key.size()) {
+                    out << std::string(get_top().min_key_width - key.size(), ' ');
+                }
+                if (get_top().set_as_type) {
+                    get_top().set_as_type = false;
+                    out << " = <span class='type'>" << value << "</span>";
+                } else {
+                    out << " = <span class='val'>" << value << "</span>";
+                }
+                if (!value_description.empty()) {
+                    out << " (<span class='val'>" << value_description << "</span>)";
+                    value_description = {};
+                }
+                out << "</summary></details>\n";
+                break;
+            case (OutputType::json):
+            case (OutputType::vkconfig_output):
+                if (!get_top().is_first_item) {
+                    out << ",\n";
+                } else {
+                    get_top().is_first_item = false;
+                }
+                out << std::string(static_cast<size_t>(get_top().indents), '\t');
+                if (!get_top().is_array) {
+                    out << "\"" << key << "\": ";
+                }
+                if (!value_description.empty()) {
+                    out << "\"" << value << " (" << value_description << ")\"";
+                    value_description = {};
+                } else {
+                    out << value;
+                }
+            default:
+                break;
+        }
+    }
+
+    // Need a specialization to handle C style arrays since they are implicitly converted to pointers
+    template <size_t N>
+    void PrintKeyValue(std::string key, const uint8_t (&values)[N]) {
+        switch (output_type) {
+            case (OutputType::json): {
+                ArrayStart(key, N);
+                for (uint32_t i = 0; i < N; i++) {
+                    PrintElement(static_cast<uint32_t>(values[i]));
+                }
+                ArrayEnd();
+                break;
+            }
+            default: {
+                std::array<uint8_t, N> arr{};
+                std::copy(std::begin(values), std::end(values), std::begin(arr));
+                PrintKeyString(key, to_string(arr));
+                break;
+            }
+        }
+    }
+
+    // For printing key - string pairs (necessary because of json)
+    void PrintKeyString(std::string key, std::string value) {
+        switch (output_type) {
+            case (OutputType::text):
+            case (OutputType::html):
+                PrintKeyValue(key, value);
+                break;
+            case (OutputType::json):
+            case (OutputType::vkconfig_output):
+                if (!value_description.empty()) {
+                    // PrintKeyValue adds the necessary quotes when printing with a value description set
+                    PrintKeyValue(key, EscapeJSONCString(value));
+                } else {
+                    PrintKeyValue(key, std::string("\"") + EscapeJSONCString(value) + "\"");
+                }
+                break;
+            default:
+                break;
+        }
+    }
+
+    // For printing key - string pairs (necessary because of json)
+    void PrintKeyBool(std::string key, bool value) { PrintKeyValue(key, value ? "true" : "false"); }
+
+    // print inside array
+    template <typename T>
+    void PrintElement(T element) {
+        // If we are inside of an object, just use an empty string as the key
+        if (!get_top().is_array) {
+            PrintKeyValue("placeholder", element);
+            return;
+        }
+        switch (output_type) {
+            case (OutputType::text):
+                out << std::string(static_cast<size_t>(get_top().indents), '\t') << element << "\n";
+                break;
+            case (OutputType::html):
+                out << std::string(static_cast<size_t>(get_top().indents), '\t') << "<details><summary>";
+                if (get_top().set_as_type) {
+                    get_top().set_as_type = false;
+                    out << "<span class='type'>" << element << "</span>";
+                } else {
+                    out << "<span class='val'>" << element << "</span>";
+                }
+                out << "</summary></details>\n";
+                break;
+            case (OutputType::json):
+            case (OutputType::vkconfig_output):
+                if (!get_top().is_first_item) {
+                    out << ",\n";
+                } else {
+                    get_top().is_first_item = false;
+                }
+                out << std::string(static_cast<size_t>(get_top().indents), '\t') << element;
+                break;
+            default:
+                break;
+        }
+    }
+    void PrintString(std::string string) {
+        switch (output_type) {
+            case (OutputType::text):
+            case (OutputType::html):
+                PrintElement(string);
+                break;
+            case (OutputType::json):
+            case (OutputType::vkconfig_output):
+                PrintElement("\"" + EscapeJSONCString(string) + "\"");
+            default:
+                break;
+        }
+    }
+    void PrintExtension(std::string ext_name, uint32_t revision, size_t min_width = 0) {
+        switch (output_type) {
+            case (OutputType::text):
+                out << std::string(static_cast<size_t>(get_top().indents), '\t') << ext_name
+                    << std::string(min_width - ext_name.size(), ' ') << " : extension revision " << revision << "\n";
+                break;
+            case (OutputType::html):
+                out << std::string(static_cast<size_t>(get_top().indents), '\t') << "<details><summary>" << DecorateAsType(ext_name)
+                    << std::string(min_width - ext_name.size(), ' ') << " : extension revision "
+                    << DecorateAsValue(std::to_string(revision)) << "</summary></details>\n";
+                break;
+            case (OutputType::json):
+                PrintKeyValue(ext_name, revision);
+                break;
+            case (OutputType::vkconfig_output):
+                ObjectStart(ext_name);
+                PrintKeyValue("specVersion", revision);
+                ObjectEnd();
+                break;
+            default:
+                break;
+        }
+    }
+    void AddNewline() {
+        if (output_type == OutputType::text) {
+            out << "\n";
+        }
+    }
+    void IndentIncrease() {
+        if (output_type == OutputType::text) {
+            get_top().indents++;
+        }
+    }
+    void IndentDecrease() {
+        if (output_type == OutputType::text) {
+            get_top().indents--;
+            assert(get_top().indents >= 0 && "indents cannot go below zero");
+        }
+    }
+
+    std::string DecorateAsType(const std::string &input) {
+        if (output_type == OutputType::html)
+            return "<span class='type'>" + input + "</span>";
+        else
+            return input;
+    }
+
+    std::string DecorateAsValue(const std::string &input) {
+        if (output_type == OutputType::html)
+            return "<span class='val'>" + input + "</span>";
+        else
+            return input;
+    }
+
+  protected:
+    OutputType output_type;
+    std::ostream &out;
+
+    struct StackNode {
+        int indents = 0;
+
+        // header, subheader
+        bool set_next_header = false;
+        bool set_next_subheader = false;
+
+        // html coloring
+        bool set_as_type = false;
+
+        // open <details>
+        bool set_details_open = false;
+
+        // always open <details>
+        bool should_always_open = false;
+
+        // make object titles the color of types
+        bool set_object_name_as_type = false;
+
+        // ignores the min_width parameter
+        bool ignore_min_width_parameter = false;
+
+        // sets the next created object/child to ignore the min_width parameter
+        bool ignore_min_width_parameter_in_child = false;
+
+        // keep track of the spacing between names and values
+        size_t min_key_width = 0;
+
+        // objects which are in an array
+        int element_index = -1;  // negative one is the sentinel value
+
+        // json
+        bool is_first_item;  // for json: for adding a comma in between objects
+        bool is_array;       // for json: match pairs of {}'s and []'s
+    };
+
+    // Contains the details about the current 'object' in the tree
+    std::stack<StackNode> object_stack;
+
+    // Helper to get the current top of the object_stack
+    StackNode &get_top() { return object_stack.top(); }
+
+    // Optional 'description' for values
+    // Must be set right before the Print() function is called
+    std::string value_description;
+
+    // can only be called after a node was manually pushed onto the stack in the constructor
+    void push_node(bool array) {
+        StackNode node{};
+        node.indents = get_top().indents + 1;
+        node.is_array = array;
+        node.is_first_item = true;
+        node.ignore_min_width_parameter = get_top().ignore_min_width_parameter_in_child;
+        object_stack.push(node);
+    }
+
+    // utility
+    void PrintHeaderUnderlines(size_t length) {
+        assert(get_top().indents >= 0 && "indents must not be negative");
+        assert(length <= 10000 && "length shouldn't be unreasonably large");
+        if (get_top().set_next_header) {
+            out << std::string(static_cast<size_t>(get_top().indents), '\t') << std::string(length, '=') << "\n";
+            get_top().set_next_header = false;
+        } else if (get_top().set_next_subheader) {
+            out << std::string(static_cast<size_t>(get_top().indents), '\t') << std::string(length, '-') << "\n";
+            get_top().set_next_subheader = false;
+        }
+    }
+
+    // Replace special characters in strings with their escaped versions.
+    // <https://www.json.org/json-en.html>
+    std::string EscapeJSONCString(std::string string) {
+        if (output_type == OutputType::text || output_type == OutputType::html) return string;
+        std::string out{};
+        for (size_t i = 0; i < string.size(); i++) {
+            char c = string[i];
+            char out_c = c;
+            switch (c) {
+                case '\"':
+                case '\\':
+                    out.push_back('\\');
+                    break;
+                case '\b':
+                    out.push_back('\\');
+                    out_c = 'b';
+                    break;
+                case '\f':
+                    out.push_back('\\');
+                    out_c = 'f';
+                    break;
+                case '\n':
+                    out.push_back('\\');
+                    out_c = 'n';
+                    break;
+                case '\r':
+                    out.push_back('\\');
+                    out_c = 'r';
+                    break;
+                case '\t':
+                    out.push_back('\\');
+                    out_c = 't';
+                    break;
+            }
+            out.push_back(out_c);
+        }
+
+        return out;
+    }
+};
+// Purpose: When a Printer starts an object or array it will automatically indent the output. This isn't
+// always desired, requiring a manual decrease of indention. This wrapper facilitates that while also
+// automatically re-indenting the output to the previous indent level on scope exit.
+class IndentWrapper {
+  public:
+    IndentWrapper(Printer &p) : p(p) {
+        if (p.Type() == OutputType::text) p.IndentDecrease();
+    }
+    ~IndentWrapper() {
+        if (p.Type() == OutputType::text) p.IndentIncrease();
+    }
+
+  private:
+    Printer &p;
+};
+
+class ObjectWrapper {
+  public:
+    ObjectWrapper(Printer &p, std::string object_name) : p(p) { p.ObjectStart(object_name); }
+    ObjectWrapper(Printer &p, std::string object_name, size_t count_subobjects) : p(p) {
+        p.ObjectStart(object_name, static_cast<int32_t>(count_subobjects));
+    }
+    ~ObjectWrapper() { p.ObjectEnd(); }
+
+  private:
+    Printer &p;
+};
+
+class ArrayWrapper {
+  public:
+    ArrayWrapper(Printer &p, std::string array_name, size_t element_count = 0) : p(p) { p.ArrayStart(array_name, element_count); }
+    ~ArrayWrapper() { p.ArrayEnd(); }
+
+  private:
+    Printer &p;
+};
diff --git a/tools/Vulkan-Tools/vulkaninfo/vulkaninfo.cpp b/tools/Vulkan-Tools/vulkaninfo/vulkaninfo.cpp
new file mode 100644
index 00000000..2c11226a
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/vulkaninfo.cpp
@@ -0,0 +1,1604 @@
+/*
+ * Copyright (c) 2015-2026 The Khronos Group Inc.
+ * Copyright (c) 2015-2026 Valve Corporation
+ * Copyright (c) 2015-2026 LunarG, Inc.
+ * Copyright (c) 2023-2024 RasterGrid Kft.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
+ * Author: David Pinedo <david@lunarg.com>
+ * Author: Mark Lobodzinski <mark@lunarg.com>
+ * Author: Rene Lindsay <rene@lunarg.com>
+ * Author: Jeremy Kniager <jeremyk@lunarg.com>
+ * Author: Shannon McPherson <shannon@lunarg.com>
+ * Author: Bob Ellison <bob@lunarg.com>
+ * Author: Richard Wright <richard@lunarg.com>
+ * Author: Charles Giessen <charles@lunarg.com>
+ *
+ */
+
+#include <string>
+#ifdef _WIN32
+#include <crtdbg.h>
+#endif
+#include "vulkaninfo.hpp"
+
+// Used to sort the formats into buckets by their properties.
+std::unordered_map<PropFlags, std::set<VkFormat>> FormatPropMap(AppGpu &gpu) {
+    std::unordered_map<PropFlags, std::set<VkFormat>> map;
+    for (const auto fmtRange : format_ranges) {
+        if (gpu.FormatRangeSupported(fmtRange)) {
+            for (int32_t fmt = fmtRange.first_format; fmt <= fmtRange.last_format; ++fmt) {
+                PropFlags pf = get_format_properties(gpu, static_cast<VkFormat>(fmt));
+                map[pf].insert(static_cast<VkFormat>(fmt));
+            }
+        }
+    }
+    return map;
+}
+
+// =========== Dump Functions ========= //
+
+void DumpExtensions(Printer &p, std::string section_name, std::vector<VkExtensionProperties> extensions, bool do_indent = false) {
+    std::sort(extensions.begin(), extensions.end(), [](VkExtensionProperties &a, VkExtensionProperties &b) -> int {
+        return std::string(a.extensionName) < std::string(b.extensionName);
+    });
+
+    size_t max_length = 0;
+    for (const auto &ext : extensions) {
+        max_length = std::max(max_length, std::strlen(ext.extensionName));
+    }
+#if defined(VK_ENABLE_BETA_EXTENSIONS)
+    const std::string portability_ext_name = VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME;
+#endif  // defined(VK_ENABLE_BETA_EXTENSIONS)
+    ObjectWrapper obj(p, section_name, extensions.size());
+    if (do_indent) p.IndentDecrease();
+    for (auto &ext : extensions) {
+#if defined(VK_ENABLE_BETA_EXTENSIONS)
+        if (p.Type() == OutputType::json && portability_ext_name == ext.extensionName) continue;
+#endif  // defined(VK_ENABLE_BETA_EXTENSIONS)
+        p.PrintExtension(ext.extensionName, ext.specVersion, max_length);
+    }
+    if (do_indent) p.IndentIncrease();
+}
+
+void DumpLayers(Printer &p, std::vector<LayerExtensionList> layers, const std::vector<std::unique_ptr<AppGpu>> &gpus) {
+    std::sort(layers.begin(), layers.end(), [](LayerExtensionList &left, LayerExtensionList &right) -> int {
+        return std::strncmp(left.layer_properties.layerName, right.layer_properties.layerName, VK_MAX_DESCRIPTION_SIZE) < 0;
+    });
+    switch (p.Type()) {
+        case OutputType::text:
+        case OutputType::html: {
+            p.SetHeader();
+            ArrayWrapper arr_layers(p, "Layers", layers.size());
+            IndentWrapper indent(p);
+
+            for (auto &layer : layers) {
+                std::string v_str = APIVersion(layer.layer_properties.specVersion);
+                auto props = layer.layer_properties;
+
+                std::string header = p.DecorateAsType(props.layerName) + " (" + props.description + ") " API_NAME " version " +
+                                     p.DecorateAsValue(v_str) + ", layer version " +
+                                     p.DecorateAsValue(std::to_string(props.implementationVersion));
+                ObjectWrapper obj(p, header);
+                DumpExtensions(p, "Layer Extensions", layer.extension_properties);
+
+                ObjectWrapper arr_devices(p, "Devices", gpus.size());
+                for (auto &gpu : gpus) {
+                    p.SetValueDescription(std::string(gpu->props.deviceName)).PrintKeyValue("GPU id", gpu->id);
+                    auto exts = gpu->inst.AppGetPhysicalDeviceLayerExtensions(gpu->phys_device, props.layerName);
+                    DumpExtensions(p, "Layer-Device Extensions", exts);
+                    p.AddNewline();
+                }
+            }
+            break;
+        }
+
+        case OutputType::json: {
+            assert(false && "unimplemented");
+            break;
+        }
+        case OutputType::vkconfig_output: {
+            ObjectWrapper obj(p, "Layer Properties");
+            for (auto &layer : layers) {
+                ObjectWrapper obj_name(p, layer.layer_properties.layerName);
+                p.SetMinKeyWidth(21);
+                p.PrintKeyString("layerName", layer.layer_properties.layerName);
+                p.PrintKeyString("version", APIVersion(layer.layer_properties.specVersion).str());
+                p.PrintKeyValue("implementation version", layer.layer_properties.implementationVersion);
+                p.PrintKeyString("description", layer.layer_properties.description);
+                DumpExtensions(p, "Layer Extensions", layer.extension_properties);
+                ObjectWrapper obj_devices(p, "Devices");
+                for (auto &gpu : gpus) {
+                    ObjectWrapper obj_gpu(p, gpu->props.deviceName);
+                    p.SetValueDescription(std::string(gpu->props.deviceName)).PrintKeyValue("GPU id", gpu->id);
+                    auto exts = gpu->inst.AppGetPhysicalDeviceLayerExtensions(gpu->phys_device, layer.layer_properties.layerName);
+                    DumpExtensions(p, "Layer-Device Extensions", exts);
+                }
+            }
+            break;
+        }
+    }
+}
+
+void DumpSurfaceFormats(Printer &p, AppInstance &inst, AppSurface &surface) {
+    std::vector<VkSurfaceFormatKHR> formats;
+    if (inst.CheckExtensionEnabled(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME)) {
+        for (auto &format : surface.surf_formats2) {
+            formats.push_back(format.surfaceFormat);
+        }
+    } else {
+        for (auto &format : surface.surf_formats) {
+            formats.push_back(format);
+        }
+    }
+    ObjectWrapper obj(p, "Formats", formats.size());
+    int i = 0;
+    for (auto &format : formats) {
+        p.SetElementIndex(i++);
+        DumpVkSurfaceFormatKHR(p, "SurfaceFormat", format);
+    }
+}
+
+void DumpPresentModes(Printer &p, AppSurface &surface) {
+    ArrayWrapper arr(p, "Present Modes", surface.surf_present_modes.size());
+    for (auto &mode : surface.surf_present_modes) {
+        p.SetAsType().PrintString(VkPresentModeKHRString(mode));
+    }
+}
+
+void DumpSurfaceCapabilities(Printer &p, AppInstance &inst, AppGpu &gpu, AppSurface &surface) {
+    auto &surf_cap = surface.surface_capabilities;
+    p.SetSubHeader().SetIgnoreMinWidthInChild();
+    DumpVkSurfaceCapabilitiesKHR(p, "VkSurfaceCapabilitiesKHR", surf_cap);
+
+    if (inst.CheckExtensionEnabled(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME)) {
+        p.SetSubHeader();
+        ObjectWrapper obj(p, "VkSurfaceCapabilities2EXT");
+        DumpVkSurfaceCounterFlagsEXT(p, "supportedSurfaceCounters", surface.surface_capabilities2_ext.supportedSurfaceCounters);
+    }
+    if (inst.CheckExtensionEnabled(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME)) {
+        chain_iterator_surface_capabilities2(p, inst, gpu, surface.surface_capabilities2_khr.pNext);
+    }
+    if (inst.CheckExtensionEnabled(VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME) ||
+        inst.CheckExtensionEnabled(VK_KHR_SURFACE_MAINTENANCE_1_EXTENSION_NAME)) {
+        const char *surf_ext_name = VK_KHR_SURFACE_MAINTENANCE_1_EXTENSION_NAME;
+        if (!inst.CheckExtensionEnabled(VK_KHR_SURFACE_MAINTENANCE_1_EXTENSION_NAME)) {
+            surf_ext_name = VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME;
+        }
+        p.SetSubHeader();
+        ObjectWrapper obj(p, surf_ext_name);
+        for (auto &mode : surface.surf_present_modes) {
+            VkSurfacePresentModeKHR present_mode{};
+            present_mode.sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR;
+            present_mode.presentMode = mode;
+
+            VkPhysicalDeviceSurfaceInfo2KHR surface_info{};
+            surface_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
+            surface_info.surface = surface.surface_extension.surface;
+            surface_info.pNext = &present_mode;
+
+            VkSurfacePresentModeCompatibilityKHR SurfacePresentModeCompatibilityKHR{};
+            SurfacePresentModeCompatibilityKHR.sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR;
+
+            VkSurfacePresentScalingCapabilitiesKHR SurfacePresentScalingCapabilitiesKHR{};
+            SurfacePresentScalingCapabilitiesKHR.sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT;
+            SurfacePresentScalingCapabilitiesKHR.pNext = &SurfacePresentModeCompatibilityKHR;
+
+            VkSurfaceCapabilities2KHR surface_caps2{};
+            surface_caps2.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR;
+            surface_caps2.pNext = &SurfacePresentScalingCapabilitiesKHR;
+
+            VkResult err = vkGetPhysicalDeviceSurfaceCapabilities2KHR(gpu.phys_device, &surface_info, &surface_caps2);
+            if (err != VK_SUCCESS) {
+                continue;
+            }
+
+            std::vector<VkPresentModeKHR> compatible_present_modes{SurfacePresentModeCompatibilityKHR.presentModeCount};
+            SurfacePresentModeCompatibilityKHR.pPresentModes = compatible_present_modes.data();
+
+            err = vkGetPhysicalDeviceSurfaceCapabilities2KHR(gpu.phys_device, &surface_info, &surface_caps2);
+
+            if (err == VK_SUCCESS) {
+                ObjectWrapper present_mode_obj(p, VkPresentModeKHRString(mode));
+
+                p.PrintKeyValue("minImageCount", surface_caps2.surfaceCapabilities.minImageCount);
+                p.PrintKeyValue("maxImageCount", surface_caps2.surfaceCapabilities.maxImageCount);
+
+                DumpVkSurfacePresentScalingCapabilitiesKHR(p, "VkSurfacePresentScalingCapabilitiesKHR",
+                                                           SurfacePresentScalingCapabilitiesKHR);
+                DumpVkSurfacePresentModeCompatibilityKHR(p, "VkSurfacePresentModeCompatibilityKHR",
+                                                         SurfacePresentModeCompatibilityKHR);
+            }
+        }
+    }
+}
+
+void DumpSurface(Printer &p, AppInstance &inst, AppGpu &gpu, AppSurface &surface, std::set<std::string> surface_types) {
+    std::string surface_type_list_str = "";
+    if (surface_types.size() > 0) {
+        surface_type_list_str = " [";
+        bool is_first = true;
+        for (auto &name : surface_types) {
+            if (!is_first) {
+                surface_type_list_str += ", ";
+            } else {
+                is_first = false;
+            }
+            surface_type_list_str += name;
+        }
+        surface_type_list_str += "]";
+    }
+    ObjectWrapper obj(p, std::string("GPU id : ") + p.DecorateAsValue(std::to_string(gpu.id)) + " (" + gpu.props.deviceName + ")" +
+                             surface_type_list_str);
+
+    if (surface_types.size() == 0) {
+        p.SetAsType().PrintKeyString("Surface type", "No type found");
+    } else if (surface_types.size() == 1) {
+        p.SetAsType().PrintKeyString("Surface type", surface.surface_extension.name);
+    } else {
+        ArrayWrapper arr(p, "Surface types", surface_types.size());
+        for (auto &name : surface_types) {
+            p.PrintString(name);
+        }
+    }
+
+    DumpSurfaceFormats(p, inst, surface);
+    DumpPresentModes(p, surface);
+    DumpSurfaceCapabilities(p, inst, gpu, surface);
+
+    p.AddNewline();
+}
+
+struct SurfaceTypeGroup {
+    AppSurface *surface;
+    AppGpu *gpu;
+    std::set<std::string> surface_types;
+};
+
+bool operator==(AppSurface const &a, AppSurface const &b) {
+    return a.phys_device == b.phys_device && a.surf_present_modes == b.surf_present_modes && a.surf_formats == b.surf_formats &&
+           a.surf_formats2 == b.surf_formats2 && a.surface_capabilities == b.surface_capabilities &&
+           a.surface_capabilities2_khr == b.surface_capabilities2_khr && a.surface_capabilities2_ext == b.surface_capabilities2_ext;
+}
+
+#if defined(VULKANINFO_WSI_ENABLED)
+void DumpPresentableSurfaces(Printer &p, AppInstance &inst, const std::vector<std::unique_ptr<AppGpu>> &gpus,
+                             const std::vector<std::unique_ptr<AppSurface>> &surfaces) {
+    // Don't print anything if no surfaces are found
+    if (surfaces.size() == 0) return;
+    p.SetHeader();
+    ObjectWrapper obj(p, "Presentable Surfaces");
+    IndentWrapper indent(p);
+
+    std::vector<SurfaceTypeGroup> surface_list;
+
+    for (auto &surface : surfaces) {
+        auto exists = surface_list.end();
+        for (auto it = surface_list.begin(); it != surface_list.end(); it++) {
+            // check for duplicate surfaces that differ only by the surface extension
+            if (*(it->surface) == *(surface.get())) {
+                exists = it;
+                break;
+            }
+        }
+        if (exists != surface_list.end()) {
+            exists->surface_types.insert(surface.get()->surface_extension.name);
+        } else {
+            // find surface.phys_device's corresponding AppGpu
+            AppGpu *corresponding_gpu = nullptr;
+            for (auto &gpu : gpus) {
+                if (gpu->phys_device == surface->phys_device) corresponding_gpu = gpu.get();
+            }
+            if (corresponding_gpu != nullptr)
+                surface_list.push_back({surface.get(), corresponding_gpu, {surface.get()->surface_extension.name}});
+        }
+    }
+    for (auto &group : surface_list) {
+        DumpSurface(p, inst, *group.gpu, *group.surface, group.surface_types);
+    }
+    p.AddNewline();
+}
+#endif  // defined(VULKANINFO_WSI_ENABLED)
+
+void DumpGroups(Printer &p, AppInstance &inst) {
+    if (inst.CheckExtensionEnabled(VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME)) {
+        auto groups = GetGroups(inst);
+        if (groups.size() == 0) {
+            p.SetHeader();
+            ObjectWrapper obj(p, "Groups");
+            p.PrintString("No Device Groups Found");
+            p.AddNewline();
+            return;
+        }
+
+        p.SetHeader();
+        ObjectWrapper obj_device_groups(p, "Device Groups");
+        IndentWrapper indent(p);
+
+        int group_id = 0;
+        for (auto &group : groups) {
+            ObjectWrapper obj_group(p, "Group " + std::to_string(group_id));
+            auto group_props = GetGroupProps(inst, group);
+            {
+                ObjectWrapper obj_properties(p, "Properties");
+                {
+                    ArrayWrapper arr(p, "physicalDevices", group.physicalDeviceCount);
+                    int id = 0;
+                    for (auto &prop : group_props) {
+                        p.PrintString(std::string(prop.deviceName) + " (ID: " + p.DecorateAsValue(std::to_string(id++)) + ")");
+                    }
+                }
+                p.PrintKeyValue("subsetAllocation", group.subsetAllocation);
+            }
+            p.AddNewline();
+
+            auto group_capabilities = GetGroupCapabilities(inst, group);
+            if (!group_capabilities) {
+                p.PrintKeyString("Present Capabilities",
+                                 "Group does not support VK_KHR_device_group, skipping printing present capabilities");
+            } else {
+                ObjectWrapper obj_caps(p, "Present Capabilities");
+                for (uint32_t i = 0; i < group.physicalDeviceCount; i++) {
+                    ObjectWrapper obj_device(
+                        p, std::string(group_props[i].deviceName) + " (ID: " + p.DecorateAsValue(std::to_string(i)) + ")");
+                    ArrayWrapper arr(p, "Can present images from the following devices", group.physicalDeviceCount);
+
+                    for (uint32_t j = 0; j < group.physicalDeviceCount; j++) {
+                        uint32_t mask = 1 << j;
+                        if (group_capabilities->presentMask[i] & mask) {
+                            p.PrintString(std::string(group_props[j].deviceName) + " (ID: " + p.DecorateAsValue(std::to_string(j)) +
+                                          ")");
+                        }
+                    }
+                }
+                DumpVkDeviceGroupPresentModeFlagsKHR(p, "Present modes", group_capabilities->modes);
+            }
+            p.AddNewline();
+            group_id++;
+        }
+        p.AddNewline();
+    }
+}
+
+void GpuDumpProps(Printer &p, AppGpu &gpu, bool show_promoted_structs) {
+    auto props = gpu.GetDeviceProperties();
+    p.SetSubHeader();
+    {
+        ObjectWrapper obj(p, "VkPhysicalDeviceProperties");
+        p.SetMinKeyWidth(17);
+        if (p.Type() == OutputType::json) {
+            p.PrintKeyValue("apiVersion", props.apiVersion);
+            p.PrintKeyValue("driverVersion", props.driverVersion);
+        } else {
+            p.SetValueDescription(std::to_string(props.apiVersion)).PrintKeyString("apiVersion", APIVersion(props.apiVersion));
+            p.SetValueDescription(std::to_string(props.driverVersion))
+                .PrintKeyString("driverVersion", gpu.GetDriverVersionString());
+        }
+        p.PrintKeyString("vendorID", to_hex_str(props.vendorID));
+        p.PrintKeyString("deviceID", to_hex_str(props.deviceID));
+        p.PrintKeyString("deviceType", VkPhysicalDeviceTypeString(props.deviceType));
+        p.PrintKeyString("deviceName", props.deviceName);
+        p.PrintKeyValue("pipelineCacheUUID", props.pipelineCacheUUID);
+    }
+    p.AddNewline();
+    DumpVkPhysicalDeviceLimits(p, "VkPhysicalDeviceLimits", gpu.props.limits);
+    p.AddNewline();
+    DumpVkPhysicalDeviceSparseProperties(p, "VkPhysicalDeviceSparseProperties", gpu.props.sparseProperties);
+    p.AddNewline();
+    if (gpu.inst.CheckExtensionEnabled(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
+        void *place = gpu.props2.pNext;
+        chain_iterator_phys_device_props2(p, gpu.inst, gpu, show_promoted_structs, place);
+    }
+}
+
+void GpuDumpQueueProps(Printer &p, AppGpu &gpu, const AppQueueFamilyProperties &queue) {
+    VkQueueFamilyProperties props = queue.props;
+    p.SetSubHeader().SetElementIndex(static_cast<int>(queue.queue_index));
+    ObjectWrapper obj_queue_props(p, "queueProperties");
+    p.SetMinKeyWidth(27);
+    if (p.Type() == OutputType::vkconfig_output) {
+        DumpVkExtent3D(p, "minImageTransferGranularity", props.minImageTransferGranularity);
+    } else {
+        p.PrintKeyValue("minImageTransferGranularity", props.minImageTransferGranularity);
+    }
+    p.PrintKeyValue("queueCount", props.queueCount);
+    p.PrintKeyString("queueFlags", VkQueueFlagsString(props.queueFlags));
+    p.PrintKeyValue("timestampValidBits", props.timestampValidBits);
+
+    if (!queue.can_present) {
+        p.PrintKeyString("present support", "false");
+    } else if (queue.can_always_present) {
+        p.PrintKeyString("present support", "true");
+    } else {
+        size_t width = 0;
+        for (const auto &support : queue.present_support) {
+            if (support.first.size() > width) width = support.first.size();
+        }
+        ObjectWrapper obj_present_support(p, "present support");
+        p.SetMinKeyWidth(width);
+        for (const auto &support : queue.present_support) {
+            p.PrintKeyString(support.first, support.second ? "true" : "false");
+        }
+    }
+    chain_iterator_queue_properties2(p, gpu, queue.pNext);
+
+    p.AddNewline();
+}
+
+// This prints a number of bytes in a human-readable format according to prefixes of the International System of Quantities (ISQ),
+// defined in ISO/IEC 80000. The prefixes used here are not SI prefixes, but rather the binary prefixes based on powers of 1024
+// (kibi-, mebi-, gibi- etc.).
+#define kBufferSize 32
+
+std::string NumToNiceStr(const size_t sz) {
+    const char prefixes[] = "KMGTPEZY";
+    char buf[kBufferSize];
+    int which = -1;
+    double result = (double)sz;
+    while (result > 1024 && which < 7) {
+        result /= 1024;
+        ++which;
+    }
+
+    char unit[] = "\0i";
+    if (which >= 0) {
+        unit[0] = prefixes[which];
+    }
+#ifdef _WIN32
+    _snprintf_s(buf, kBufferSize * sizeof(char), kBufferSize, "%.2f %sB", result, unit);
+#else
+    snprintf(buf, kBufferSize, "%.2f %sB", result, unit);
+#endif
+    return std::string(buf);
+}
+
+std::string append_human_readable(VkDeviceSize memory) {
+    return std::to_string(memory) + " (" + to_hex_str(memory) + ") (" + NumToNiceStr(static_cast<size_t>(memory)) + ")";
+}
+
+void GpuDumpMemoryProps(Printer &p, AppGpu &gpu) {
+    p.SetHeader();
+    ObjectWrapper obj_mem_props(p, "VkPhysicalDeviceMemoryProperties");
+    IndentWrapper indent(p);
+    {
+        ObjectWrapper obj_mem_heaps(p, "memoryHeaps", gpu.memory_props.memoryHeapCount);
+
+        for (uint32_t i = 0; i < gpu.memory_props.memoryHeapCount; ++i) {
+            p.SetElementIndex(static_cast<int>(i));
+            ObjectWrapper obj_mem_heap(p, "memoryHeaps");
+            p.SetMinKeyWidth(6);
+            p.PrintKeyString("size", append_human_readable(gpu.memory_props.memoryHeaps[i].size));
+            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_MEMORY_BUDGET_EXTENSION_NAME)) {
+                p.PrintKeyString("budget", append_human_readable(gpu.heapBudget[i]));
+                p.PrintKeyString("usage", append_human_readable(gpu.heapUsage[i]));
+            }
+            DumpVkMemoryHeapFlags(p, "flags", gpu.memory_props.memoryHeaps[i].flags);
+        }
+    }
+    {
+        ObjectWrapper obj_mem_types(p, "memoryTypes", gpu.memory_props.memoryTypeCount);
+        for (uint32_t i = 0; i < gpu.memory_props.memoryTypeCount; ++i) {
+            p.SetElementIndex(static_cast<int>(i));
+            ObjectWrapper obj_mem_type(p, "memoryTypes");
+            p.SetMinKeyWidth(13);
+            p.PrintKeyValue("heapIndex", gpu.memory_props.memoryTypes[i].heapIndex);
+
+            auto flags = gpu.memory_props.memoryTypes[i].propertyFlags;
+            DumpVkMemoryPropertyFlags(p, "propertyFlags = " + to_hex_str(flags), flags);
+
+            ObjectWrapper usable_for(p, "usable for");
+            const uint32_t memtype_bit = 1U << i;
+
+            // only linear and optimal tiling considered
+            for (auto &image_tiling : gpu.memory_image_support_types) {
+                p.SetOpenDetails();
+                ArrayWrapper arr(p, VkImageTilingString(VkImageTiling(image_tiling.tiling)));
+                bool has_any_support_types = false;
+                bool regular = false;
+                bool transient = false;
+                bool sparse = false;
+                for (auto &image_format : image_tiling.formats) {
+                    if (image_format.type_support.size() > 0) {
+                        bool has_a_support_type = false;
+                        for (auto &img_type : image_format.type_support) {
+                            if (img_type.Compatible(memtype_bit)) {
+                                has_a_support_type = true;
+                                has_any_support_types = true;
+                                if (img_type.type == ImageTypeSupport::Type::regular) regular = true;
+                                if (img_type.type == ImageTypeSupport::Type::transient) transient = true;
+                                if (img_type.type == ImageTypeSupport::Type::sparse) sparse = true;
+                            }
+                        }
+                        if (has_a_support_type) {
+                            if (image_format.format == color_format) {
+                                p.PrintString("color images");
+                            } else {
+                                p.PrintString(VkFormatString(image_format.format));
+                            }
+                        }
+                    }
+                }
+                if (!has_any_support_types) {
+                    p.PrintString("None");
+                } else {
+                    if (regular && !transient && sparse) p.PrintString("(non-transient)");
+                    if (regular && transient && !sparse) p.PrintString("(non-sparse)");
+                    if (regular && !transient && !sparse) p.PrintString("(non-sparse, non-transient)");
+                    if (!regular && transient && sparse) p.PrintString("(sparse and transient only)");
+                    if (!regular && !transient && sparse) p.PrintString("(sparse only)");
+                    if (!regular && transient && !sparse) p.PrintString("(transient only)");
+                }
+            }
+        }
+    }
+    p.AddNewline();
+}
+
+void GpuDumpFeatures(Printer &p, AppGpu &gpu, bool show_promoted_structs) {
+    p.SetHeader();
+    DumpVkPhysicalDeviceFeatures(p, "VkPhysicalDeviceFeatures", gpu.features);
+    p.AddNewline();
+    if (gpu.inst.CheckExtensionEnabled(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
+        void *place = gpu.features2.pNext;
+        chain_iterator_phys_device_features2(p, gpu, show_promoted_structs, place);
+    }
+}
+
+void GpuDumpTextFormatProperty(Printer &p, const AppGpu &gpu, PropFlags formats, const std::set<VkFormat> &format_list,
+                               uint32_t counter) {
+    p.SetElementIndex(counter);
+    ObjectWrapper obj_common_group(p, "Common Format Group");
+    IndentWrapper indent_inner(p);
+    {
+        ArrayWrapper arr_formats(p, "Formats", format_list.size());
+        for (auto &fmt : format_list) {
+            p.SetAsType().PrintString(VkFormatString(fmt));
+        }
+    }
+    ObjectWrapper obj(p, "Properties");
+    if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME)) {
+        DumpVkFormatFeatureFlags2(p, "linearTilingFeatures", formats.props3.linearTilingFeatures);
+        DumpVkFormatFeatureFlags2(p, "optimalTilingFeatures", formats.props3.optimalTilingFeatures);
+        DumpVkFormatFeatureFlags2(p, "bufferFeatures", formats.props3.bufferFeatures);
+    } else {
+        DumpVkFormatFeatureFlags(p, "linearTilingFeatures", formats.props.linearTilingFeatures);
+        DumpVkFormatFeatureFlags(p, "optimalTilingFeatures", formats.props.optimalTilingFeatures);
+        DumpVkFormatFeatureFlags(p, "bufferFeatures", formats.props.bufferFeatures);
+    }
+    p.AddNewline();
+}
+
+void GpuDumpToolingInfo(Printer &p, AppGpu &gpu) {
+    auto tools = GetToolingInfo(gpu);
+    if (tools.size() > 0) {
+        p.SetSubHeader();
+        ObjectWrapper obj(p, "Tooling Info");
+        for (auto tool : tools) {
+            DumpVkPhysicalDeviceToolProperties(p, tool.name, tool);
+            p.AddNewline();
+        }
+    }
+}
+
+void GpuDumpCooperativeMatrix(Printer &p, AppGpu &gpu) {
+    auto props = GetCooperativeMatrixInfo(gpu);
+    if (props.size() > 0) {
+        p.SetSubHeader();
+        ObjectWrapper obj(p, "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR");
+        for (const auto prop : props) {
+            DumpVkCooperativeMatrixPropertiesKHR(p, "VkCooperativeMatrixPropertiesKHR", prop);
+            p.AddNewline();
+        }
+    }
+}
+
+void GpuDumpCalibrateableTimeDomain(Printer &p, AppGpu &gpu) {
+    auto props = GetTimeDomainInfo(gpu);
+    if (props.size() > 0) {
+        p.SetSubHeader();
+        ObjectWrapper obj_mem_props(p, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR");
+        {
+            for (uint32_t i = 0; i < props.size(); ++i) {
+                p.SetElementIndex(static_cast<int>(i));
+                DumpVkTimeDomainKHR(p, "pTimeDomains", props[i]);
+                p.AddNewline();
+            }
+        }
+    }
+}
+
+void GpuDumpFragmentShadingRate(Printer &p, AppGpu &gpu) {
+    auto props = GetFragmentShadingRateInfo(gpu);
+    if (props.size() > 0) {
+        p.SetSubHeader();
+        ObjectWrapper obj(p, "vkGetPhysicalDeviceFragmentShadingRatesKHR");
+        for (const auto prop : props) {
+            DumpVkPhysicalDeviceFragmentShadingRateKHR(p, "VkPhysicalDeviceFragmentShadingRateKHR", prop);
+            p.AddNewline();
+        }
+    }
+}
+
+// VK_EXT_sample_locations ('Multisample Properties' is too ambiguous of a name)
+void GpuDumpSampleLocations(Printer &p, AppGpu &gpu) {
+    auto props = GetSampleLocationInfo(gpu);
+    if (props.size() > 0) {
+        p.SetSubHeader();
+        ObjectWrapper obj(p, "vkGetPhysicalDeviceMultisamplePropertiesEXT");
+        for (uint32_t i = 0; i < props.size(); i++) {
+            const VkSampleCountFlagBits sample_count = (VkSampleCountFlagBits)(1 << i);
+            DumpVkSampleCountFlagBits(p, "samples", sample_count);
+            DumpVkMultisamplePropertiesEXT(p, "VkMultisamplePropertiesEXT", props[i]);
+            p.AddNewline();
+        }
+    }
+}
+
+void GpuDevDump(Printer &p, AppGpu &gpu) {
+    p.SetHeader();
+    ObjectWrapper obj_format_props(p, "Format Properties");
+    IndentWrapper indent_outer(p);
+
+    if (p.Type() == OutputType::text) {
+        auto fmtPropMap = FormatPropMap(gpu);
+        int counter = 0;
+        std::set<VkFormat> unsupported_formats;
+        for (auto &prop : fmtPropMap) {
+            VkFormatProperties props = prop.first.props;
+            VkFormatProperties3 props3 = prop.first.props3;
+            if (props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0 && props.bufferFeatures == 0 &&
+                props3.linearTilingFeatures == 0 && props3.optimalTilingFeatures == 0 && props3.bufferFeatures == 0) {
+                unsupported_formats = prop.second;
+                continue;
+            }
+            GpuDumpTextFormatProperty(p, gpu, prop.first, prop.second, counter++);
+        }
+
+        ArrayWrapper arr_unsupported_formats(p, "Unsupported Formats", unsupported_formats.size());
+        for (auto &fmt : unsupported_formats) {
+            p.SetAsType().PrintString(VkFormatString(fmt));
+        }
+    } else {
+        std::set<VkFormat> formats_to_print;
+        for (auto &format_range : format_ranges) {
+            if (gpu.FormatRangeSupported(format_range)) {
+                for (int32_t fmt_counter = format_range.first_format; fmt_counter <= format_range.last_format; ++fmt_counter) {
+                    formats_to_print.insert(static_cast<VkFormat>(fmt_counter));
+                }
+            }
+        }
+        for (const auto &fmt : formats_to_print) {
+            auto formats = get_format_properties(gpu, fmt);
+            p.SetTitleAsType();
+            if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME)) {
+                DumpVkFormatProperties3(p, VkFormatString(fmt), formats.props3);
+            } else {
+                DumpVkFormatProperties(p, VkFormatString(fmt), formats.props);
+            }
+        }
+    }
+
+    p.AddNewline();
+}
+
+void DumpVkVideoProfileInfoKHRCustom(Printer &p, std::string name, const VkVideoProfileInfoKHR &obj) {
+    // We use custom dumping here because we do not want to output ignored fields
+    // e.g. for monochrome chromaBitDepth is ignored
+    ObjectWrapper object{p, name};
+    DumpVkVideoCodecOperationFlagBitsKHR(p, "videoCodecOperation", obj.videoCodecOperation);
+    DumpVkVideoChromaSubsamplingFlagsKHR(p, "chromaSubsampling", obj.chromaSubsampling);
+    DumpVkVideoComponentBitDepthFlagsKHR(p, "lumaBitDepth", obj.lumaBitDepth);
+    if (obj.chromaSubsampling != VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR) {
+        DumpVkVideoComponentBitDepthFlagsKHR(p, "chromaBitDepth", obj.chromaBitDepth);
+    } else {
+        DumpVkVideoComponentBitDepthFlagsKHR(p, "chromaBitDepth", 0);
+    }
+}
+
+void GpuDumpVideoProfiles(Printer &p, AppGpu &gpu, bool show_video_props) {
+    p.SetHeader();
+    ObjectWrapper video_profiles_obj(p, "Video Profiles", gpu.video_profiles.size());
+    IndentWrapper indent_outer(p);
+
+    if (p.Type() != OutputType::text || show_video_props) {
+        // Video profile details per profile
+        for (const auto &video_profile : gpu.video_profiles) {
+            p.SetSubHeader();
+            ObjectWrapper video_profile_obj(p, video_profile->name);
+            IndentWrapper indent_inner(p);
+            {
+                p.SetSubHeader();
+                ObjectWrapper profile_info_obj(p, "Video Profile Definition");
+                p.SetSubHeader();
+                DumpVkVideoProfileInfoKHRCustom(p, "VkVideoProfileInfoKHR", video_profile->profile_info);
+                chain_iterator_video_profile_info(p, gpu, video_profile->profile_info.pNext);
+            }
+            {
+                p.SetSubHeader();
+                ObjectWrapper capabilities_obj(p, "Video Profile Capabilities");
+                p.SetSubHeader();
+                DumpVkVideoCapabilitiesKHR(p, "VkVideoCapabilitiesKHR", video_profile->capabilities);
+                chain_iterator_video_capabilities(p, gpu, video_profile->capabilities.pNext);
+            }
+            {
+                p.SetSubHeader();
+                ObjectWrapper video_formats_obj(p, "Video Formats");
+                for (const auto &video_formats_it : video_profile->formats_by_category) {
+                    const auto &video_format_category_name = video_formats_it.first;
+                    const auto &video_format_props = video_formats_it.second;
+                    ObjectWrapper video_format_category(p, video_format_category_name, video_format_props.size());
+                    for (size_t i = 0; i < video_format_props.size(); ++i) {
+                        ObjectWrapper video_format_obj(p, video_format_category_name + " Format #" + std::to_string(i + 1));
+                        p.SetSubHeader();
+                        DumpVkVideoFormatPropertiesKHR(p, "VkVideoFormatPropertiesKHR", video_format_props[i]);
+                        chain_iterator_video_format_properties(p, gpu, video_format_props[i].pNext);
+                    }
+                }
+            }
+
+            p.AddNewline();
+        }
+    } else {
+        // Video profile list only
+        for (const auto &video_profile : gpu.video_profiles) {
+            p.PrintString(video_profile->name);
+        }
+    }
+
+    p.AddNewline();
+}
+
+AppDisplayPlane::AppDisplayPlane(AppGpu &gpu, uint32_t index, const VkDisplayPlanePropertiesKHR &in_prop)
+    : global_index(index), properties(in_prop) {
+    std::ostringstream display_name;
+
+    supported_displays = GetVector<VkDisplayKHR>("vkGetDisplayPlaneSupportedDisplaysKHR", vkGetDisplayPlaneSupportedDisplaysKHR,
+                                                 gpu.phys_device, global_index);
+}
+
+std::vector<AppDisplayPlane> enumerate_display_planes(AppGpu &gpu) {
+    std::vector<AppDisplayPlane> result;
+    if (vkGetPhysicalDeviceDisplayPlanePropertiesKHR) {
+        auto planes = GetVector<VkDisplayPlanePropertiesKHR>("vkGetPhysicalDeviceDisplayPlanePropertiesKHR",
+                vkGetPhysicalDeviceDisplayPlanePropertiesKHR, gpu.phys_device);
+        for (uint32_t i = 0; i < planes.size(); i++) {
+            result.emplace_back(gpu, i, planes[i]);
+        }
+    }
+    return result;
+}
+
+AppDisplayMode::AppDisplayMode(AppGpu &gpu, const VkDisplayModePropertiesKHR &in_properties,
+                               const std::set<uint32_t> &supported_planes)
+    : properties(in_properties) {
+    for (auto plane : supported_planes) {
+        VkDisplayPlaneCapabilitiesKHR cap;
+
+        vkGetDisplayPlaneCapabilitiesKHR(gpu.phys_device, properties.displayMode, plane, &cap);
+        capabilities[plane] = cap;
+    }
+}
+
+static std::string MakeName(uint32_t index, const VkDisplayPropertiesKHR &prop) {
+    std::stringstream name;
+    name << "Display id : " << index << " (" << prop.displayName << ")";
+    return name.str();
+}
+
+AppDisplay::AppDisplay(AppGpu &gpu, uint32_t index, const VkDisplayPropertiesKHR &in_properties,
+                       const std::vector<AppDisplayPlane> &all_planes)
+    : global_index(index), name(MakeName(index, in_properties)), properties(in_properties) {
+    auto mode_props = GetVector<VkDisplayModePropertiesKHR>("vkGetDisplayModePropertiesKHR", vkGetDisplayModePropertiesKHR,
+                                                            gpu.phys_device, properties.display);
+
+    std::set<uint32_t> supported_planes;
+    for (const auto &plane : all_planes) {
+        for (const auto &display : plane.supported_displays) {
+            if (display == properties.display) {
+                supported_planes.insert(plane.global_index);
+            }
+        }
+    }
+
+    for (const auto &prop : mode_props) {
+        modes.emplace_back(gpu, prop, supported_planes);
+    }
+}
+
+std::vector<AppDisplay> enumerate_displays(AppGpu &gpu, const std::vector<AppDisplayPlane> &all_planes) {
+    std::vector<AppDisplay> result;
+
+    if (vkGetPhysicalDeviceDisplayPropertiesKHR) {
+        auto properties = GetVector<VkDisplayPropertiesKHR>("vkGetPhysicalDeviceDisplayPropertiesKHR",
+                vkGetPhysicalDeviceDisplayPropertiesKHR, gpu.phys_device);
+
+        for (uint32_t i = 0; i < properties.size(); i++) {
+            result.emplace_back(gpu, i, properties[i], all_planes);
+        }
+    }
+    return result;
+}
+
+void GpuDumpDisplays(Printer &p, AppGpu &gpu) {
+    if (gpu.displays.size() == 0) {
+        return;
+    }
+
+    p.SetHeader();
+    ObjectWrapper display_props_obj(p, "Display Properties", gpu.displays.size());
+
+    for (const auto &display : gpu.displays) {
+        p.SetSubHeader();
+        ObjectWrapper display_obj(p, display.name);
+
+        DumpVkDisplayPropertiesKHR(p, "VkDisplayPropertiesKHR", display.properties);
+        ArrayWrapper arr(p, "Display Modes", display.modes.size());
+
+        for (uint32_t m = 0; m < display.modes.size(); m++) {
+            const auto &mode = display.modes[m];
+            std::ostringstream mode_name;
+            mode_name << "Display Mode : " << p.DecorateAsValue(std::to_string(m)) << " ("
+                      << mode.properties.parameters.visibleRegion.width << " x " << mode.properties.parameters.visibleRegion.height
+                      << ")";
+
+            ObjectWrapper mode_obj(p, mode_name.str());
+
+            DumpVkDisplayModeParametersKHR(p, "VkDisplayModeParametersKHR", mode.properties.parameters);
+
+            ArrayWrapper cap_arr(p, "Display Plane Capabilities", mode.capabilities.size());
+            for (const auto &cap : mode.capabilities) {
+                std::ostringstream cap_name;
+                cap_name << "Capabilities (Plane " << p.DecorateAsValue(std::to_string(cap.first)) << ")";
+
+                ObjectWrapper cap_obj(p, cap_name.str());
+
+                DumpVkDisplayPlaneCapabilitiesKHR(p, "VkDisplayPlaneCapabilitiesKHR", cap.second);
+            }
+        }
+    }
+}
+
+void GpuDumpDisplayPlanes(Printer &p, AppGpu &gpu) {
+    if (gpu.display_planes.size() == 0) {
+        return;
+    }
+
+    p.SetHeader();
+    ObjectWrapper display_props_obj(p, "Display Plane Properties", gpu.display_planes.size());
+
+    for (const auto &plane : gpu.display_planes) {
+        p.SetSubHeader();
+        ObjectWrapper display_obj(p, std::string("Display Plane id : ") + p.DecorateAsValue(std::to_string(plane.global_index)));
+
+        auto *current = gpu.FindDisplay(plane.properties.currentDisplay);
+
+        p.PrintKeyString("currentDisplay", current ? current->name.c_str() : "none");
+
+        DumpVkDisplayPlanePropertiesKHR(p, "VkDisplayPlanePropertiesKHR", plane.properties);
+
+        ArrayWrapper arr(p, "Supported Displays", plane.supported_displays.size());
+        for (auto handle : plane.supported_displays) {
+            auto *display = gpu.FindDisplay(handle);
+            p.SetAsType().PrintString(display ? display->name.c_str() : "UNKNOWN");
+        }
+    }
+}
+
+struct ShowSettings {
+    bool all = false;
+    bool tool_props = false;
+    bool formats = false;
+    bool promoted_structs = false;
+    bool video_props = false;
+};
+
+// Print gpu info for text, html, & vkconfig_output
+// Uses a separate function than schema-json for clarity
+void DumpGpu(Printer &p, AppGpu &gpu, const ShowSettings &show) {
+    ObjectWrapper obj_gpu(p, "GPU" + std::to_string(gpu.id));
+    IndentWrapper indent(p);
+
+    GpuDumpProps(p, gpu, show.promoted_structs);
+    DumpExtensions(p, "Device Extensions", gpu.device_extensions);
+    p.AddNewline();
+    {
+        p.SetHeader();
+        ObjectWrapper obj_family_props(p, "VkQueueFamilyProperties");
+        for (const auto &queue_prop : gpu.extended_queue_props) {
+            GpuDumpQueueProps(p, gpu, queue_prop);
+        }
+    }
+    GpuDumpMemoryProps(p, gpu);
+    GpuDumpFeatures(p, gpu, show.promoted_structs);
+    if (show.tool_props) {
+        GpuDumpToolingInfo(p, gpu);
+    }
+
+    if (show.all) {
+        GpuDumpCooperativeMatrix(p, gpu);
+        GpuDumpCalibrateableTimeDomain(p, gpu);
+        GpuDumpFragmentShadingRate(p, gpu);
+        GpuDumpSampleLocations(p, gpu);
+    }
+
+    if (p.Type() != OutputType::text || show.formats) {
+        GpuDevDump(p, gpu);
+    }
+
+    if (!gpu.video_profiles.empty()) {
+        GpuDumpVideoProfiles(p, gpu, show.video_props);
+    }
+
+    if (!gpu.displays.empty()) {
+        GpuDumpDisplays(p, gpu);
+    }
+
+    if (!gpu.display_planes.empty()) {
+        GpuDumpDisplayPlanes(p, gpu);
+    }
+
+    p.AddNewline();
+}
+
+// Print capabilities section of profiles schema
+void DumpGpuProfileCapabilities(Printer &p, AppGpu &gpu, bool show_promoted_structs) {
+    ObjectWrapper capabilities(p, "capabilities");
+    {
+        ObjectWrapper temp_name_obj(p, "device");
+        DumpExtensions(p, "extensions", gpu.device_extensions);
+        {
+            ObjectWrapper obj(p, "features");
+            GpuDumpFeatures(p, gpu, show_promoted_structs);
+        }
+        {
+            ObjectWrapper obj(p, "properties");
+            {
+                ObjectWrapper props_obj(p, "VkPhysicalDeviceProperties");
+                auto props = gpu.GetDeviceProperties();
+                p.PrintKeyValue("apiVersion", props.apiVersion);
+                p.PrintKeyValue("deviceID", props.deviceID);
+                p.PrintKeyString("deviceName", props.deviceName);
+                p.PrintKeyString("deviceType", std::string("VK_") + VkPhysicalDeviceTypeString(props.deviceType));
+                p.PrintKeyValue("driverVersion", props.driverVersion);
+
+                DumpVkPhysicalDeviceLimits(p, "VkPhysicalDeviceLimits", gpu.props.limits);
+                {
+                    ArrayWrapper arr(p, "pipelineCacheUUID");
+                    for (const auto &uuid : props.pipelineCacheUUID) p.PrintElement(static_cast<uint32_t>(uuid));
+                }
+                DumpVkPhysicalDeviceSparseProperties(p, "VkPhysicalDeviceSparseProperties", gpu.props.sparseProperties);
+                p.PrintKeyValue("vendorID", props.vendorID);
+            }
+            if (gpu.inst.CheckExtensionEnabled(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
+                void *place = gpu.props2.pNext;
+                chain_iterator_phys_device_props2(p, gpu.inst, gpu, show_promoted_structs, place);
+            }
+        }
+        {
+            ObjectWrapper obj(p, "formats");
+            std::set<VkFormat> already_printed_formats;
+            for (const auto &format : format_ranges) {
+                if (gpu.FormatRangeSupported(format)) {
+                    for (int32_t fmt_counter = format.first_format; fmt_counter <= format.last_format; ++fmt_counter) {
+                        VkFormat fmt = static_cast<VkFormat>(fmt_counter);
+                        if (already_printed_formats.count(fmt) > 0) {
+                            continue;
+                        }
+                        auto formats = get_format_properties(gpu, fmt);
+
+                        // don't print format properties that are unsupported
+                        if (formats.props.linearTilingFeatures == 0 && formats.props.optimalTilingFeatures == 0 &&
+                            formats.props.bufferFeatures == 0 && formats.props3.linearTilingFeatures == 0 &&
+                            formats.props3.optimalTilingFeatures == 0 && formats.props3.bufferFeatures == 0)
+                            continue;
+
+                        ObjectWrapper format_obj(p, std::string("VK_") + VkFormatString(fmt));
+                        {
+                            // Want to explicitly list VkFormatProperties in addition to VkFormatProperties3 if available
+                            DumpVkFormatProperties(p, "VkFormatProperties", formats.props);
+                            VkFormatProperties2 format_props2{};
+                            format_props2.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2;
+                            format_props2.formatProperties = formats.props;
+                            std::unique_ptr<format_properties2_chain> chain_for_format_props2;
+                            setup_format_properties2_chain(format_props2, chain_for_format_props2, gpu);
+                            vkGetPhysicalDeviceFormatProperties2KHR(gpu.phys_device, fmt, &format_props2);
+                            chain_iterator_format_properties2(p, gpu, format_props2.pNext);
+                        }
+                        already_printed_formats.insert(fmt);
+                    }
+                }
+            }
+        }
+        {
+            ArrayWrapper arr(p, "queueFamiliesProperties");
+            for (const auto &extended_queue_prop : gpu.extended_queue_props) {
+                ObjectWrapper queue_obj(p, "");
+                {
+                    ObjectWrapper obj_queue_props(p, "VkQueueFamilyProperties");
+                    VkQueueFamilyProperties props = extended_queue_prop.props;
+                    DumpVkExtent3D(p, "minImageTransferGranularity", props.minImageTransferGranularity);
+                    p.PrintKeyValue("queueCount", props.queueCount);
+                    DumpVkQueueFlags(p, "queueFlags", props.queueFlags);
+                    p.PrintKeyValue("timestampValidBits", props.timestampValidBits);
+                }
+                chain_iterator_queue_properties2(p, gpu, extended_queue_prop.pNext);
+            }
+        }
+        if (!gpu.video_profiles.empty()) {
+            ArrayWrapper video_profiles(p, "videoProfiles");
+            for (const auto &video_profile : gpu.video_profiles) {
+                ObjectWrapper video_profile_obj(p, "");
+                {
+                    ObjectWrapper profile_info_obj(p, "profile");
+                    DumpVkVideoProfileInfoKHRCustom(p, "VkVideoProfileInfoKHR", video_profile->profile_info);
+                    chain_iterator_video_profile_info(p, gpu, video_profile->profile_info.pNext);
+                }
+                {
+                    ObjectWrapper capabilities_obj(p, "capabilities");
+                    DumpVkVideoCapabilitiesKHR(p, "VkVideoCapabilitiesKHR", video_profile->capabilities);
+                    chain_iterator_video_capabilities(p, gpu, video_profile->capabilities.pNext);
+                }
+                {
+                    ArrayWrapper video_formats(p, "formats");
+                    for (const auto &video_format : video_profile->formats) {
+                        ObjectWrapper video_format_obj(p, "");
+                        DumpVkVideoFormatPropertiesKHR(p, "VkVideoFormatPropertiesKHR", video_format.properties);
+                        chain_iterator_video_format_properties(p, gpu, video_format.properties.pNext);
+                    }
+                }
+            }
+        }
+    }
+#if defined(VK_ENABLE_BETA_EXTENSIONS)
+    // Print portability subset extension, features, and properties if available
+    if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME) &&
+        (gpu.inst.CheckExtensionEnabled(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME) ||
+         gpu.inst.api_version >= VK_API_VERSION_1_1)) {
+        ObjectWrapper macos_obj(p, "macos-specific");
+        {
+            ObjectWrapper ext_obj(p, "extensions");
+            const std::string portability_ext_name = VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME;
+            for (const auto &ext : gpu.device_extensions) {
+                if (portability_ext_name == ext.extensionName) {
+                    p.PrintExtension(ext.extensionName, ext.specVersion);
+                }
+            }
+        }
+        {
+            ObjectWrapper features_obj(p, "features");
+            void *feats_place = gpu.features2.pNext;
+            while (feats_place) {
+                VkBaseOutStructure *structure = static_cast<VkBaseOutStructure *>(feats_place);
+                if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR) {
+                    auto *features = reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(structure);
+                    DumpVkPhysicalDevicePortabilitySubsetFeaturesKHR(p, "VkPhysicalDevicePortabilitySubsetFeaturesKHR", *features);
+                    break;
+                }
+                feats_place = structure->pNext;
+            }
+        }
+        {
+            ObjectWrapper property_obj(p, "properties");
+            void *props_place = gpu.props2.pNext;
+            while (props_place) {
+                VkBaseOutStructure *structure = static_cast<VkBaseOutStructure *>(props_place);
+                if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR) {
+                    auto *props = reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR *>(structure);
+                    DumpVkPhysicalDevicePortabilitySubsetPropertiesKHR(p, "VkPhysicalDevicePortabilitySubsetPropertiesKHR", *props);
+                    break;
+                }
+                props_place = structure->pNext;
+            }
+        }
+    }
+#endif  // defined(VK_ENABLE_BETA_EXTENSIONS)
+}
+void PrintProfileBaseInfo(Printer &p, const std::string &device_name, uint32_t apiVersion, const std::string &device_label,
+                          const std::vector<std::string> &capabilities) {
+    ObjectWrapper vk_info(p, device_name);
+    p.PrintKeyValue("version", 1);
+    p.PrintKeyString("api-version", APIVersion(apiVersion).str());
+    p.PrintKeyString("label", device_label);
+    p.PrintKeyString("description", std::string("Exported from ") + APP_SHORT_NAME);
+    {
+        ObjectWrapper contributors(p, "contributors");
+    }
+    {
+        ArrayWrapper contributors(p, "history");
+        ObjectWrapper element(p, "");
+        p.PrintKeyValue("revision", 1);
+        std::time_t t = std::time(0);  // get time now
+        std::tm *now = std::localtime(&t);
+        std::string date =
+            std::to_string(now->tm_year + 1900) + '-' + std::to_string(now->tm_mon + 1) + '-' + std::to_string(now->tm_mday);
+        p.PrintKeyString("date", date);
+        p.PrintKeyString("author", std::string("Automated export from ") + APP_SHORT_NAME);
+        p.PrintKeyString("comment", "");
+    }
+    ArrayWrapper contributors(p, "capabilities");
+    for (const auto &str : capabilities) p.PrintString(str);
+}
+
+// Prints profiles section of profiles schema
+void DumpGpuProfileInfo(Printer &p, AppGpu &gpu) {
+    ObjectWrapper profiles(p, "profiles");
+
+    std::string device_label = std::string(gpu.props.deviceName) + " driver " + gpu.GetDriverVersionString();
+    std::string device_name =
+        std::string("VP_" APP_UPPER_CASE_NAME "_") + std::string(gpu.props.deviceName) + "_" + gpu.GetDriverVersionString();
+    ;
+    for (auto &c : device_name) {
+        if (c == ' ' || c == '.') c = '_';
+    }
+    PrintProfileBaseInfo(p, device_name, gpu.props.apiVersion, device_label, {"device"});
+#if defined(VK_ENABLE_BETA_EXTENSIONS)
+    if (gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME) &&
+        (gpu.inst.CheckExtensionEnabled(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME) ||
+         gpu.inst.api_version >= VK_API_VERSION_1_1)) {
+        PrintProfileBaseInfo(p, device_name + "_portability_subset", gpu.props.apiVersion, device_label + " subset",
+                             {"device", "macos-specific"});
+    }
+#endif  // defined(VK_ENABLE_BETA_EXTENSIONS)
+}
+
+// Print summary of system
+void DumpSummaryInstance(Printer &p, AppInstance &inst) {
+    p.SetSubHeader();
+    DumpExtensions(p, "Instance Extensions", inst.global_extensions, true);
+    p.AddNewline();
+
+    p.SetSubHeader();
+    ArrayWrapper arr(p, "Instance Layers", inst.global_layers.size());
+    IndentWrapper indent(p);
+    std::sort(inst.global_layers.begin(), inst.global_layers.end(), [](LayerExtensionList &left, LayerExtensionList &right) -> int {
+        return std::strncmp(left.layer_properties.layerName, right.layer_properties.layerName, VK_MAX_DESCRIPTION_SIZE) < 0;
+    });
+    size_t layer_name_max = 0;
+    size_t layer_desc_max = 0;
+    size_t layer_version_max = 0;
+
+    // find max of each type to align everything in columns
+    for (auto &layer : inst.global_layers) {
+        auto props = layer.layer_properties;
+        layer_name_max = std::max(layer_name_max, strlen(props.layerName));
+        layer_desc_max = std::max(layer_desc_max, strlen(props.description));
+        layer_version_max = std::max(layer_version_max, APIVersion(layer.layer_properties.specVersion).str().size());
+    }
+    for (auto &layer : inst.global_layers) {
+        auto v_str = APIVersion(layer.layer_properties.specVersion).str();
+        auto props = layer.layer_properties;
+
+        auto name_padding = std::string(layer_name_max - strlen(props.layerName), ' ');
+        auto desc_padding = std::string(layer_desc_max - strlen(props.description), ' ');
+        auto version_padding = std::string(layer_version_max - v_str.size(), ' ');
+        p.PrintString(std::string(props.layerName) + name_padding + " " + props.description + desc_padding + " " + v_str + " " +
+                      version_padding + " version " + std::to_string(props.implementationVersion));
+    }
+    p.AddNewline();
+}
+
+void DumpSummaryGPU(Printer &p, AppGpu &gpu) {
+    ObjectWrapper obj(p, "GPU" + std::to_string(gpu.id));
+    p.SetMinKeyWidth(18);
+    auto props = gpu.GetDeviceProperties();
+    p.PrintKeyValue("apiVersion", APIVersion(props.apiVersion));
+    if (gpu.found_driver_props) {
+        p.PrintKeyString("driverVersion", gpu.GetDriverVersionString());
+    } else {
+        p.PrintKeyValue("driverVersion", props.driverVersion);
+    }
+    p.PrintKeyString("vendorID", to_hex_str(props.vendorID));
+    p.PrintKeyString("deviceID", to_hex_str(props.deviceID));
+    p.PrintKeyString("deviceType", VkPhysicalDeviceTypeString(props.deviceType));
+    p.PrintKeyString("deviceName", props.deviceName);
+
+    if (gpu.found_driver_props) {
+        DumpVkDriverId(p, "driverID", gpu.driverID);
+        p.PrintKeyString("driverName", gpu.driverName);
+        p.PrintKeyString("driverInfo", gpu.driverInfo);
+        p.PrintKeyValue("conformanceVersion", gpu.conformanceVersion);
+    }
+    if (gpu.found_device_id_props) {
+        p.PrintKeyValue("deviceUUID", gpu.deviceUUID);
+        p.PrintKeyValue("driverUUID", gpu.driverUUID);
+    }
+}
+
+// ============ Printing Logic ============= //
+
+#ifdef _WIN32
+// Enlarges the console window to have a large scrollback size.
+static void ConsoleEnlarge() {
+    const HANDLE console_handle = GetStdHandle(STD_OUTPUT_HANDLE);
+
+    // make the console window bigger
+    CONSOLE_SCREEN_BUFFER_INFO csbi;
+    COORD buffer_size;
+    if (GetConsoleScreenBufferInfo(console_handle, &csbi)) {
+        buffer_size.X = csbi.dwSize.X + 30;
+        buffer_size.Y = 20000;
+        SetConsoleScreenBufferSize(console_handle, buffer_size);
+    }
+
+    SMALL_RECT r;
+    r.Left = r.Top = 0;
+    r.Right = csbi.dwSize.X - 1 + 30;
+    r.Bottom = 50;
+    SetConsoleWindowInfo(console_handle, true, &r);
+
+    // change the console window title
+    SetConsoleTitle(TEXT(APP_SHORT_NAME));
+}
+#endif
+
+// Global configuration
+enum class OutputCategory { text, html, profile_json, vkconfig_output, summary };
+const char *help_message_body =
+    "OPTIONS:\n"
+    "[-h, --help]         Print this help.\n"
+    "[--summary]          Show a summary of the instance and GPU's on a system.\n"
+    "[-o <filename>, --output <filename>]\n"
+    "                     Print output to a new file whose name is specified by filename.\n"
+    "                     File will be written to the current working directory.\n"
+    "[--text]             Produce a text version of " APP_SHORT_NAME
+    " output to stdout. This is\n"
+    "                     the default output.\n"
+    "[--html]             Produce an html version of " APP_SHORT_NAME
+    " output, saved as\n"
+    "                     \"" APP_SHORT_NAME
+    ".html\" in the directory in which the command\n"
+    "                     is run.\n"
+    "[-j, --json]         Produce a json version of " APP_SHORT_NAME
+    " output conforming to the Vulkan\n"
+    "                     Profiles schema, saved as \n"
+    "                     \"VP_" APP_UPPER_CASE_NAME
+    "_[DEVICE_NAME]_[DRIVER_VERSION].json\"\n"
+    "                     of the first gpu in the system.\n"
+    "[-j=<gpu-number>, --json=<gpu-number>]\n"
+    "                     For a multi-gpu system, a single gpu can be targeted by\n"
+    "                     specifying the gpu-number associated with the gpu of \n"
+    "                     interest. This number can be determined by running\n"
+    "                     " APP_SHORT_NAME
+    " without any options specified.\n"
+    "[--show-all]         Show everything (includes all the below options)\n"
+    "[--show-tool-props]  Show the active VkPhysicalDeviceToolPropertiesEXT that " APP_SHORT_NAME
+    " finds.\n"
+    "[--show-formats]     Display the format properties of each physical device.\n"
+    "                     Note: This only affects text output.\n"
+    "[--show-promoted-structs] Include structs promoted to core in pNext Chains.\n"
+    "[--show-video-props]\n"
+    "                     Display the video profile info, video capabilities and\n"
+    "                     video format properties of each video profile supported\n"
+    "                     by each physical device.\n"
+    "                     Note: This only affects text output which by default\n"
+    "                     only contains the list of supported video profile names.\n";
+
+void print_usage(const std::string &executable_name) {
+    std::cout << "\n" APP_SHORT_NAME " - Summarize " API_NAME " information in relation to the current environment.\n\n";
+    std::cout << "USAGE: \n";
+    std::cout << "    " << executable_name << " --summary\n";
+    std::cout << "    " << executable_name << " -o <filename> | --output <filename>\n";
+    std::cout << "    " << executable_name << " -j | -j=<gpu-number> | --json | --json=<gpu-number>\n";
+    std::cout << "    " << executable_name << " --text\n";
+    std::cout << "    " << executable_name << " --html\n";
+    std::cout << "    " << executable_name << " --show-all\n";
+    std::cout << "    " << executable_name << " --show-formats\n";
+    std::cout << "    " << executable_name << " --show-tool-props\n";
+    std::cout << "    " << executable_name << " --show-promoted-structs\n";
+    std::cout << "    " << executable_name << " --show-video-props\n";
+    std::cout << "\n" << help_message_body << std::endl;
+}
+
+struct ParsedResults {
+    OutputCategory output_category = OutputCategory::text;
+    uint32_t selected_gpu = 0;
+    bool has_selected_gpu = false;  // differentiate between selecting the 0th gpu and using the default 0th value
+    ShowSettings show;
+    bool print_to_file = false;
+    std::string filename;  // set if explicitly given, or if vkconfig_output has a <path> argument
+    std::string default_filename;
+};
+
+util::vulkaninfo_optional<ParsedResults> parse_arguments(int argc, char **argv, std::string executable_name) {
+    ParsedResults results{};
+    results.default_filename = APP_SHORT_NAME ".txt";
+    for (int i = 1; i < argc; ++i) {
+        // A internal-use-only format for communication with the Vulkan Configurator tool
+        // Usage "--vkconfig_output <path>"
+        // -o can be used to specify the filename instead
+        if (0 == strcmp("--vkconfig_output", argv[i])) {
+            results.output_category = OutputCategory::vkconfig_output;
+            results.print_to_file = true;
+            results.default_filename = APP_SHORT_NAME ".json";
+            if (argc > (i + 1) && argv[i + 1][0] != '-') {
+#ifdef WIN32
+                results.filename = (std::string(argv[i + 1]) + "\\" APP_SHORT_NAME ".json");
+#else
+                results.filename = (std::string(argv[i + 1]) + "/" APP_SHORT_NAME ".json");
+#endif
+                ++i;
+            }
+        } else if (strncmp("--json", argv[i], 6) == 0 || strncmp(argv[i], "-j", 2) == 0) {
+            if (strlen(argv[i]) > 7 && strncmp("--json=", argv[i], 7) == 0) {
+                results.selected_gpu = static_cast<uint32_t>(strtol(argv[i] + 7, nullptr, 10));
+                results.has_selected_gpu = true;
+            }
+            if (strlen(argv[i]) > 3 && strncmp("-j=", argv[i], 3) == 0) {
+                results.selected_gpu = static_cast<uint32_t>(strtol(argv[i] + 3, nullptr, 10));
+                results.has_selected_gpu = true;
+            }
+            results.output_category = OutputCategory::profile_json;
+            results.default_filename = APP_SHORT_NAME ".json";
+            results.print_to_file = true;
+        } else if (strcmp(argv[i], "--summary") == 0) {
+            results.output_category = OutputCategory::summary;
+        } else if (strcmp(argv[i], "--text") == 0) {
+            results.output_category = OutputCategory::text;
+            results.default_filename = APP_SHORT_NAME ".txt";
+        } else if (strcmp(argv[i], "--html") == 0) {
+            results.output_category = OutputCategory::html;
+            results.print_to_file = true;
+            results.default_filename = APP_SHORT_NAME ".html";
+        } else if (strcmp(argv[i], "--show-all") == 0) {
+            results.show.all = true;
+            results.show.tool_props = true;
+            results.show.formats = true;
+            results.show.promoted_structs = true;
+            results.show.video_props = true;
+        } else if (strcmp(argv[i], "--show-tool-props") == 0) {
+            results.show.tool_props = true;
+        } else if (strcmp(argv[i], "--show-formats") == 0) {
+            results.show.formats = true;
+        } else if (strcmp(argv[i], "--show-promoted-structs") == 0) {
+            results.show.promoted_structs = true;
+        } else if (strcmp(argv[i], "--show-video-props") == 0) {
+            results.show.video_props = true;
+        } else if ((strcmp(argv[i], "--output") == 0 || strcmp(argv[i], "-o") == 0) && argc > (i + 1)) {
+            if (argv[i + 1][0] == '-') {
+                std::cout << "-o or --output must be followed by a filename\n";
+                return {};
+            }
+            results.print_to_file = true;
+            results.filename = argv[i + 1];
+            ++i;
+        } else if (strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "-h") == 0) {
+            print_usage(executable_name);
+            return {};
+        } else {
+            print_usage(executable_name);
+            return {};
+        }
+    }
+    return results;
+}
+
+PrinterCreateDetails get_printer_create_details(ParsedResults &parse_data, AppInstance &inst, AppGpu &selected_gpu,
+                                                std::string const &executable_name) {
+    PrinterCreateDetails create{};
+    create.print_to_file = parse_data.print_to_file;
+    create.file_name = (!parse_data.filename.empty()) ? parse_data.filename : parse_data.default_filename;
+    switch (parse_data.output_category) {
+        default:
+        case (OutputCategory::text):
+            create.output_type = OutputType::text;
+            break;
+        case (OutputCategory::html):
+            create.output_type = OutputType::html;
+            break;
+        case (OutputCategory::profile_json):
+            create.output_type = OutputType::json;
+            create.start_string =
+                std::string("{\n\t\"$schema\": ") + "\"https://schema.khronos.org/vulkan/profiles-0.8-latest.json\"";
+            if (parse_data.filename.empty()) {
+                create.file_name = std::string("VP_" APP_UPPER_CASE_NAME "_") + std::string(selected_gpu.props.deviceName) + "_" +
+                                   selected_gpu.GetDriverVersionString();
+                for (auto &c : create.file_name) {
+                    if (c == ' ' || c == '.') c = '_';
+                }
+                create.file_name += ".json";
+            }
+            break;
+        case (OutputCategory::vkconfig_output):
+            create.output_type = OutputType::vkconfig_output;
+            create.start_string = "{\n\t\"" API_NAME " Instance Version\": \"" + inst.api_version.str() + "\"";
+            break;
+    }
+    return create;
+}
+
+void RunPrinter(Printer &p, ParsedResults parse_data, AppInstance &instance, std::vector<std::unique_ptr<AppGpu>> &gpus,
+                std::vector<std::unique_ptr<AppSurface>> &surfaces) {
+#ifdef VK_USE_PLATFORM_IOS_MVK
+    p.SetAlwaysOpenDetails(true);
+#endif
+    if (parse_data.output_category == OutputCategory::summary) {
+        DumpSummaryInstance(p, instance);
+        p.SetHeader();
+        ObjectWrapper obj(p, "Devices");
+        IndentWrapper indent(p);
+        for (auto &gpu : gpus) {
+            DumpSummaryGPU(p, *(gpu.get()));
+        }
+    } else if (parse_data.output_category == OutputCategory::profile_json) {
+        DumpGpuProfileCapabilities(p, *(gpus.at(parse_data.selected_gpu).get()), parse_data.show.promoted_structs);
+        DumpGpuProfileInfo(p, *(gpus.at(parse_data.selected_gpu).get()));
+    } else {
+        // text, html, vkconfig_output
+        p.SetHeader();
+        DumpExtensions(p, "Instance Extensions", instance.global_extensions);
+        p.AddNewline();
+
+        DumpLayers(p, instance.global_layers, gpus);
+#if defined(VULKANINFO_WSI_ENABLED)
+        // Doesn't print anything if no surfaces are available
+        DumpPresentableSurfaces(p, instance, gpus, surfaces);
+#endif  // defined(VULKANINFO_WSI_ENABLED)
+        DumpGroups(p, instance);
+
+        p.SetHeader();
+        ObjectWrapper obj(p, "Device Properties and Extensions");
+        IndentWrapper indent(p);
+
+        for (auto &gpu : gpus) {
+            DumpGpu(p, *(gpu.get()), parse_data.show);
+        }
+    }
+}
+
+#ifdef VK_USE_PLATFORM_IOS_MVK
+// On iOS, we'll call this ourselves from a parent routine in the GUI
+int vulkanInfoMain(int argc, char **argv) {
+#else
+int main(int argc, char **argv) {
+#endif
+
+    // Figure out the name of the executable, pull out the name if given a path
+    // Default is `vulkaninfo`
+    std::string executable_name = APP_SHORT_NAME;
+    if (argc >= 1) {
+        const auto argv_0 = std::string(argv[0]);
+        // don't include path separator
+        // Look for forward slash first, only look for backslash if that found nothing
+        auto last_occurrence = argv_0.rfind('/');
+        if (last_occurrence == std::string::npos) {
+            last_occurrence = argv_0.rfind('\\');
+        }
+        if (last_occurrence != std::string::npos && last_occurrence + 1 < argv_0.size()) {
+            executable_name = argv_0.substr(last_occurrence + 1);
+        }
+    }
+
+    auto parsing_return = parse_arguments(argc, argv, executable_name);
+    if (!parsing_return) return 1;
+    ParsedResults parse_data = parsing_return.value();
+
+#if defined(_MSC_VER)
+    _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
+    SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
+    _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
+    _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
+
+    if (ConsoleIsExclusive()) ConsoleEnlarge();
+    User32Handles local_user32_handles;
+    user32_handles = &local_user32_handles;
+    if (!local_user32_handles.load()) {
+        fprintf(stderr, "Failed to load user32.dll library!\n");
+        if (parse_data.output_category == OutputCategory::text && !parse_data.print_to_file) wait_for_console_destroy();
+        return 1;
+    }
+#endif
+
+    int return_code = 0;  // set in case of error
+    std::unique_ptr<Printer> printer;
+    std::ostream std_out(std::cout.rdbuf());
+    std::ofstream file_out;
+    std::ostream *out = &std_out;
+
+    // if any essential vulkan call fails, it throws an exception
+    try {
+        AppInstance instance = {};
+        SetupWindowExtensions(instance);
+
+        auto phys_devices = instance.FindPhysicalDevices();
+
+#if defined(VULKANINFO_WSI_ENABLED)
+        for (auto &surface_extension : instance.surface_extensions) {
+            surface_extension.create_window(instance);
+            surface_extension.surface = surface_extension.create_surface(instance);
+        }
+#endif  // defined(VULKANINFO_WSI_ENABLED)
+
+        std::vector<std::unique_ptr<AppGpu>> gpus;
+
+        uint32_t gpu_counter = 0;
+        for (auto &phys_device : phys_devices) {
+            gpus.push_back(
+                std::unique_ptr<AppGpu>(new AppGpu(instance, gpu_counter++, phys_device, parse_data.show.promoted_structs)));
+        }
+
+        std::vector<std::unique_ptr<AppSurface>> surfaces;
+#if defined(VULKANINFO_WSI_ENABLED)
+        for (auto &surface_extension : instance.surface_extensions) {
+            for (auto &gpu : gpus) {
+                try {
+                    // check if the surface is supported by the physical device before adding it to the list
+                    VkBool32 supported = VK_FALSE;
+                    VkResult err = vkGetPhysicalDeviceSurfaceSupportKHR(gpu->phys_device, 0, surface_extension.surface, &supported);
+                    if (err != VK_SUCCESS || supported == VK_FALSE) continue;
+
+                    surfaces.push_back(
+                        std::unique_ptr<AppSurface>(new AppSurface(instance, *gpu.get(), gpu->phys_device, surface_extension)));
+                } catch (std::exception &e) {
+                    std::cerr << "ERROR while creating surface for extension " << surface_extension.name << " : " << e.what()
+                              << "\n";
+                }
+            }
+        }
+#endif  // defined(VULKANINFO_WSI_ENABLED)
+
+        if (parse_data.selected_gpu >= gpus.size()) {
+            if (parse_data.has_selected_gpu) {
+                std::cout << "The selected gpu (" << parse_data.selected_gpu << ") is not a valid GPU index. ";
+                if (gpus.size() == 0) {
+                    std::cout << APP_SHORT_NAME " could not find any GPU's.\n";
+                    return 1;
+                } else {
+                    if (gpus.size() == 1) {
+                        std::cout << "The only available GPU selection is 0.\n";
+                    } else {
+                        std::cout << "The available GPUs are in the range of 0 to " << gpus.size() - 1 << ".\n";
+                    }
+                    return 1;
+                }
+            } else if (parse_data.output_category == OutputCategory::profile_json) {
+                std::cout << APP_SHORT_NAME " could not find any GPU's.\n";
+            }
+        }
+
+        auto printer_data = get_printer_create_details(parse_data, instance, *gpus.at(parse_data.selected_gpu), executable_name);
+        if (printer_data.print_to_file) {
+            file_out = std::ofstream(printer_data.file_name);
+            out = &file_out;
+        }
+        printer = std::unique_ptr<Printer>(new Printer(printer_data, *out, instance.api_version));
+
+        RunPrinter(*(printer.get()), parse_data, instance, gpus, surfaces);
+
+        // Call the printer's destructor before the file handle gets closed
+        printer.reset(nullptr);
+#if defined(VULKANINFO_WSI_ENABLED)
+        for (auto &surface_extension : instance.surface_extensions) {
+            AppDestroySurface(instance, surface_extension.surface);
+            surface_extension.destroy_window(instance);
+        }
+#endif  // defined(VULKANINFO_WSI_ENABLED)
+    } catch (std::exception &e) {
+        // Print the error to stderr and leave all outputs in a valid state (mainly for json)
+        std::cerr << "ERROR at " << e.what() << "\n";
+        if (printer) {
+            printer->FinishOutput();
+        }
+        return_code = 1;
+
+        // Call the printer's destructor before the file handle gets closed
+        printer.reset(nullptr);
+    }
+
+#ifdef _WIN32
+    if (parse_data.output_category == OutputCategory::text && !parse_data.print_to_file) wait_for_console_destroy();
+#endif
+
+    return return_code;
+}
diff --git a/tools/Vulkan-Tools/vulkaninfo/vulkaninfo.h b/tools/Vulkan-Tools/vulkaninfo/vulkaninfo.h
new file mode 100644
index 00000000..e15583e6
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/vulkaninfo.h
@@ -0,0 +1,2035 @@
+/*
+ * Copyright (c) 2015-2026 The Khronos Group Inc.
+ * Copyright (c) 2015-2026 Valve Corporation
+ * Copyright (c) 2015-2026 LunarG, Inc.
+ * Copyright (c) 2023-2024 RasterGrid Kft.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
+ * Author: David Pinedo <david@lunarg.com>
+ * Author: Mark Lobodzinski <mark@lunarg.com>
+ * Author: Rene Lindsay <rene@lunarg.com>
+ * Author: Jeremy Kniager <jeremyk@lunarg.com>
+ * Author: Shannon McPherson <shannon@lunarg.com>
+ * Author: Bob Ellison <bob@lunarg.com>
+ * Author: Charles Giessen <charles@lunarg.com>
+ *
+ */
+#pragma once
+
+#include <algorithm>
+#include <array>
+#include <cstdint>
+#include <exception>
+#include <iostream>
+#include <fstream>
+#include <map>
+#include <memory>
+#include <ostream>
+#include <set>
+#include <string>
+#include <unordered_map>
+#include <set>
+#include <vector>
+#include <utility>
+#include <functional>
+
+#include <assert.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <cstring>
+
+#ifdef __GNUC__
+#ifndef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE 200809L
+#endif
+#else
+#define strndup(p, n) strdup(p)
+#endif
+
+#if defined(_WIN32)
+#include <fcntl.h>
+#include <io.h>
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <windows.h>
+#if _MSC_VER == 1900
+#pragma warning(disable : 4800)
+#endif
+#endif  // _WIN32
+
+#if defined(VK_USE_PLATFORM_XLIB_KHR) || defined(VK_USE_PLATFORM_XCB_KHR)
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#endif
+
+#if defined(VK_USE_PLATFORM_MACOS_MVK) || defined(VK_USE_PLATFORM_METAL_EXT)
+#include "metal_view.h"
+#endif
+
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+#include <wayland-client.h>
+#endif
+
+#include "vulkaninfo_functions.h"
+
+#include <vulkan/vulkan.h>
+
+static std::string VkResultString(VkResult err);
+
+// General error: Get file + line and a short message
+struct FileLineException : std::runtime_error {
+    FileLineException(const std::string &arg, const char *file, int line) : runtime_error(arg) {
+        msg = std::string(file) + ":" + std::to_string(line) + ": " + arg;
+    }
+    ~FileLineException() throw() {}
+    const char *what() const throw() { return msg.c_str(); }
+
+  private:
+    std::string msg;
+};
+#define THROW_ERR(arg) throw FileLineException(arg, __FILE__, __LINE__);
+
+// Vulkan function error: Get name of function, file, line, and the error code returned by the function
+struct VulkanException : std::runtime_error {
+    VulkanException(const std::string &function, const char *file, int line, VkResult err) : runtime_error(function) {
+        msg = std::string(file) + ":" + std::to_string(line) + ":" + function + " failed with " + VkResultString(err);
+    }
+    ~VulkanException() throw() {}
+    const char *what() const throw() { return msg.c_str(); }
+
+  private:
+    std::string msg;
+};
+#define THROW_VK_ERR(func_name, err) throw VulkanException(func_name, __FILE__, __LINE__, err);
+
+#ifdef _WIN32
+
+#define strdup _strdup
+
+// Returns nonzero if the console is used only for this process. Will return
+// zero if another process (such as cmd.exe) is also attached.
+static int ConsoleIsExclusive(void) {
+    DWORD pids[2];
+    DWORD num_pids = GetConsoleProcessList(pids, ARRAYSIZE(pids));
+    return num_pids <= 1;
+}
+void wait_for_console_destroy() {
+    if (ConsoleIsExclusive()) Sleep(INFINITE);
+}
+
+// User32 function declarations
+using PFN_AdjustWindowRect = WINUSERAPI BOOL(WINAPI *)(_Inout_ LPRECT, _In_ DWORD, _In_ BOOL);
+using PFN_CreateWindowExA = WINUSERAPI HWND(WINAPI *)(_In_ DWORD, _In_opt_ LPCSTR, _In_opt_ LPCSTR, _In_ DWORD, _In_ int, _In_ int,
+                                                      _In_ int, _In_ int, _In_opt_ HWND, _In_opt_ HMENU, _In_opt_ HINSTANCE,
+                                                      _In_opt_ LPVOID);
+using PFN_DefWindowProcA = WINUSERAPI LRESULT(WINAPI *)(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM);
+using PFN_DestroyWindow = WINUSERAPI BOOL(WINAPI *)(_In_ HWND);
+using PFN_LoadIconA = WINUSERAPI HICON(WINAPI *)(_In_opt_ HINSTANCE, _In_ LPCSTR);
+using PFN_RegisterClassExA = WINUSERAPI ATOM(WINAPI *)(_In_ CONST WNDCLASSEXA *);
+
+struct User32Handles {
+    // User32 dll handle
+    HMODULE user32DllHandle = nullptr;
+
+    // User32 function pointers
+    PFN_AdjustWindowRect pfnAdjustWindowRect = nullptr;
+    PFN_CreateWindowExA pfnCreateWindowExA = nullptr;
+    PFN_DefWindowProcA pfnDefWindowProcA = nullptr;
+    PFN_DestroyWindow pfnDestroyWindow = nullptr;
+    PFN_LoadIconA pfnLoadIconA = nullptr;
+    PFN_RegisterClassExA pfnRegisterClassExA = nullptr;
+
+    User32Handles() noexcept {}
+    ~User32Handles() noexcept {
+        if (user32DllHandle != nullptr) {
+            FreeLibrary(user32DllHandle);
+        }
+    }
+    // Don't allow moving of this class
+    User32Handles(User32Handles const &) = delete;
+    User32Handles &operator=(User32Handles const &) = delete;
+    User32Handles(User32Handles &&) = delete;
+    User32Handles &operator=(User32Handles &&) = delete;
+
+    bool load() {
+        user32DllHandle = LoadLibraryExA("user32.dll", nullptr, 0);
+        if (user32DllHandle == nullptr) return false;
+        if (!load_function(pfnAdjustWindowRect, "AdjustWindowRect")) return false;
+        if (!load_function(pfnCreateWindowExA, "CreateWindowExA")) return false;
+        if (!load_function(pfnDefWindowProcA, "DefWindowProcA")) return false;
+        if (!load_function(pfnDestroyWindow, "DestroyWindow")) return false;
+        if (!load_function(pfnLoadIconA, "LoadIconA")) return false;
+        if (!load_function(pfnRegisterClassExA, "RegisterClassExA")) return false;
+        return true;
+    }
+
+  private:
+    template <typename T>
+    bool load_function(T &function_pointer, const char *function_name) {
+        function_pointer = reinterpret_cast<T>(GetProcAddress(user32DllHandle, function_name));
+        if (function_pointer == nullptr) {
+            fprintf(stderr, "Failed to load function: %s\n", function_name);
+            return false;
+        }
+        return true;
+    }
+};
+
+// Global user handles function used in windows callback and code
+User32Handles *user32_handles;
+#endif  // _WIN32
+
+#define APP_SHORT_NAME "vulkaninfo"
+#define APP_UPPER_CASE_NAME "VULKANINFO"
+#define API_NAME "Vulkan"
+
+std::vector<const char *> get_c_str_array(std::vector<std::string> const &vec) {
+    std::vector<const char *> ret;
+    for (auto &str : vec) ret.push_back(str.c_str());
+    return ret;
+}
+
+static const char *VkDebugReportFlagsEXTString(const VkDebugReportFlagsEXT flags) {
+    switch (flags) {
+        case VK_DEBUG_REPORT_ERROR_BIT_EXT:
+            return "ERROR";
+        case VK_DEBUG_REPORT_WARNING_BIT_EXT:
+            return "WARNING";
+        case VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT:
+            return "PERF";
+        case VK_DEBUG_REPORT_INFORMATION_BIT_EXT:
+            return "INFO";
+        case VK_DEBUG_REPORT_DEBUG_BIT_EXT:
+            return "DEBUG";
+        default:
+            return "UNKNOWN";
+    }
+}
+static VKAPI_ATTR VkBool32 VKAPI_CALL DbgCallback(VkDebugReportFlagsEXT msgFlags, VkDebugReportObjectTypeEXT objType,
+                                                  uint64_t srcObject, size_t location, int32_t msgCode, const char *pLayerPrefix,
+                                                  const char *pMsg, void *pUserData) {
+    std::cerr << VkDebugReportFlagsEXTString(msgFlags) << ": [" << pLayerPrefix << "] Code " << msgCode << " : " << pMsg << "\n";
+
+    // True is reserved for layer developers, and MAY mean calls are not distributed down the layer chain after validation
+    // error. False SHOULD always be returned by apps:
+    return VK_FALSE;
+}
+
+// Helper for robustly executing the two-call pattern
+template <typename T, typename F, typename... Ts>
+auto GetVectorInit(const char *func_name, F &&f, T init, Ts &&...ts) -> std::vector<T> {
+    uint32_t count = 32;  // Preallocate enough so that most calls only happen once
+    std::vector<T> results;
+    VkResult err;
+    uint32_t iteration_count = 0;
+    uint32_t max_iterations = 5;
+    do {
+        count *= 2;
+        results.resize(count, init);
+        err = f(ts..., &count, results.data());
+        results.resize(count);
+        iteration_count++;
+    } while (err == VK_INCOMPLETE && iteration_count < max_iterations);
+    if (err) THROW_VK_ERR(func_name, err);
+    return results;
+}
+
+template <typename T, typename F, typename... Ts>
+auto GetVector(const char *func_name, F &&f, Ts &&...ts) -> std::vector<T> {
+    return GetVectorInit(func_name, f, T(), ts...);
+}
+
+// Forward declarations for pNext chains
+struct phys_device_props2_chain;
+struct phys_device_mem_props2_chain;
+struct phys_device_features2_chain;
+struct surface_capabilities2_chain;
+struct format_properties2_chain;
+struct queue_properties2_chain;
+struct video_profile_info_chain;
+struct video_capabilities_chain;
+struct video_format_properties_chain;
+struct AppInstance;
+struct AppGpu;
+struct AppVideoProfile;
+struct AppDisplay;
+struct AppDisplayMode;
+struct AppDisplayPlane;
+
+void setup_phys_device_props2_chain(VkPhysicalDeviceProperties2 &start, std::unique_ptr<phys_device_props2_chain> &chain,
+                                    AppInstance &inst, AppGpu &gpu, bool show_promoted_structs);
+void setup_phys_device_mem_props2_chain(VkPhysicalDeviceMemoryProperties2 &start,
+                                        std::unique_ptr<phys_device_mem_props2_chain> &chain, AppGpu &gpu);
+void setup_phys_device_features2_chain(VkPhysicalDeviceFeatures2 &start, std::unique_ptr<phys_device_features2_chain> &chain,
+                                       AppGpu &gpu, bool show_promoted_structs);
+void setup_surface_capabilities2_chain(VkSurfaceCapabilities2KHR &start, std::unique_ptr<surface_capabilities2_chain> &chain,
+                                       AppInstance &inst, AppGpu &gpu);
+void setup_format_properties2_chain(VkFormatProperties2 &start, std::unique_ptr<format_properties2_chain> &chain, AppGpu &gpu);
+void setup_queue_properties2_chain(VkQueueFamilyProperties2 &start, std::unique_ptr<queue_properties2_chain> &chain, AppGpu &gpu);
+
+bool prepare_phys_device_props2_twocall_chain_vectors(std::unique_ptr<phys_device_props2_chain> &chain);
+
+bool is_video_format_same(const VkVideoFormatPropertiesKHR &format_a, const VkVideoFormatPropertiesKHR &format_b);
+std::vector<std::unique_ptr<AppVideoProfile>> enumerate_supported_video_profiles(AppGpu &gpu);
+
+std::vector<AppDisplayPlane> enumerate_display_planes(AppGpu &gpu);
+std::vector<AppDisplay> enumerate_displays(AppGpu &gpu, const std::vector<AppDisplayPlane> &all_planes);
+
+/* An ptional contains either a value or nothing. The optional asserts if a value is trying to be gotten but none exist.
+ * The interface is taken from C++17's <optional> with many aspects removed.
+ * This class assumes the template type is 'trivial'
+ */
+namespace util {
+template <typename T>
+struct vulkaninfo_optional {
+    using value_type = T;
+
+    bool _contains_value = false;
+    value_type _value;
+
+    vulkaninfo_optional() noexcept : _contains_value(false), _value({}) {}
+    vulkaninfo_optional(T value) noexcept : _contains_value(true), _value(value) {}
+
+    explicit operator bool() const noexcept { return _contains_value; }
+    bool has_value() const noexcept { return _contains_value; }
+
+    value_type value() const noexcept {
+        assert(_contains_value);
+        return _value;
+    }
+    // clang-format off
+    const value_type* operator->() const { assert(_contains_value); return _value;}
+    value_type* operator->() { assert(_contains_value); return &_value;}
+    const value_type& operator*() const& { assert(_contains_value); return _value;}
+    value_type& operator*() & { assert(_contains_value); return _value;}
+    const value_type&& operator*() const&& { assert(_contains_value); return _value;}
+    value_type&& operator*() && { assert(_contains_value); return _value;}
+    // clang-format on
+};  // namespace util
+}  // namespace util
+struct LayerExtensionList {
+    VkLayerProperties layer_properties;
+    std::vector<VkExtensionProperties> extension_properties;
+};
+
+struct AppInstance;
+
+struct SurfaceExtension {
+    std::string name;
+    void (*create_window)(AppInstance &) = nullptr;
+    VkSurfaceKHR (*create_surface)(AppInstance &) = nullptr;
+    void (*destroy_window)(AppInstance &) = nullptr;
+    VkSurfaceKHR surface = VK_NULL_HANDLE;
+
+    bool operator==(const SurfaceExtension &other) { return name == other.name && surface == other.surface; }
+};
+
+struct AppVideoProfile {
+    bool supported;
+
+    std::string name;
+
+    VkVideoProfileInfoKHR profile_info;
+    std::unique_ptr<video_profile_info_chain> profile_info_chain;
+
+    VkVideoCapabilitiesKHR capabilities;
+    std::unique_ptr<video_capabilities_chain> capabilities_chain;
+
+    struct Format {
+        VkVideoFormatPropertiesKHR properties;
+        std::unique_ptr<video_format_properties_chain> properties_chain;
+    };
+    std::vector<Format> formats;
+    std::unordered_map<std::string, std::vector<VkVideoFormatPropertiesKHR>> formats_by_category;
+
+    using CreateProfileInfoChainCb = std::function<std::unique_ptr<video_profile_info_chain>(const void **)>;
+    using CreateCapabilitiesChainCb = std::function<std::unique_ptr<video_capabilities_chain>(void **)>;
+    struct CreateFormatPropertiesChainCb {
+        std::string format_name;
+        VkImageUsageFlags image_usage_flags;
+        std::function<bool(const VkVideoCapabilitiesKHR &capabilities)> check_required_caps;
+        std::function<std::unique_ptr<video_format_properties_chain>(void **)> callback;
+    };
+    using CreateFormatPropertiesChainCbList = std::vector<CreateFormatPropertiesChainCb>;
+    using InitProfileCb = std::function<void(AppVideoProfile &)>;
+
+    AppVideoProfile(AppGpu &gpu, VkPhysicalDevice phys_device, const std::string &in_name,
+                    const VkVideoProfileInfoKHR &in_profile_info, CreateProfileInfoChainCb create_profile_info_chain,
+                    CreateCapabilitiesChainCb create_capabilities_chain,
+                    const CreateFormatPropertiesChainCbList &create_format_properties_chain_list, InitProfileCb init_profile)
+        : supported(true), name(in_name), profile_info(in_profile_info), capabilities({}) {
+        profile_info_chain = create_profile_info_chain(&profile_info.pNext);
+        if (profile_info_chain == nullptr) {
+            supported = false;
+            return;
+        }
+
+        capabilities.sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR;
+        capabilities.pNext = nullptr;
+        capabilities_chain = create_capabilities_chain(&capabilities.pNext);
+        if (capabilities_chain == nullptr) {
+            supported = false;
+            return;
+        }
+
+        init_profile(*this);
+
+        VkResult result = vkGetPhysicalDeviceVideoCapabilitiesKHR(phys_device, &profile_info, &capabilities);
+        if (result != VK_SUCCESS) {
+            supported = false;
+            return;
+        }
+
+        VkVideoProfileListInfoKHR profile_list = {VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR, nullptr, 1, &profile_info};
+
+        std::vector<VkVideoFormatPropertiesKHR> video_format_props{};
+        std::vector<std::unique_ptr<video_format_properties_chain>> video_format_props_chains{};
+        for (const auto &create_format_properties_chain_info : create_format_properties_chain_list) {
+            if (!create_format_properties_chain_info.check_required_caps(capabilities)) {
+                continue;
+            }
+
+            VkPhysicalDeviceVideoFormatInfoKHR video_format_info = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR,
+                                                                    &profile_list,
+                                                                    create_format_properties_chain_info.image_usage_flags};
+
+            uint32_t video_format_property_count = 0;
+            result =
+                vkGetPhysicalDeviceVideoFormatPropertiesKHR(phys_device, &video_format_info, &video_format_property_count, nullptr);
+            if (result != VK_SUCCESS) {
+                continue;
+            }
+
+            video_format_props.resize(video_format_property_count);
+            video_format_props_chains.resize(video_format_property_count);
+
+            for (uint32_t i = 0; i < video_format_property_count; ++i) {
+                video_format_props[i].sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR;
+                video_format_props_chains[i] = create_format_properties_chain_info.callback(&video_format_props[i].pNext);
+            }
+
+            result = vkGetPhysicalDeviceVideoFormatPropertiesKHR(phys_device, &video_format_info, &video_format_property_count,
+                                                                 video_format_props.data());
+            if (result == VK_SUCCESS) {
+                for (uint32_t i = 0; i < video_format_property_count; ++i) {
+                    const VkVideoFormatPropertiesKHR *existing_format = nullptr;
+                    for (const auto &format : formats) {
+                        if (is_video_format_same(format.properties, video_format_props[i])) {
+                            existing_format = &format.properties;
+                            break;
+                        }
+                    }
+                    if (existing_format == nullptr) {
+                        formats.push_back(Format{video_format_props[i], std::move(video_format_props_chains[i])});
+                        formats_by_category[create_format_properties_chain_info.format_name].push_back(video_format_props[i]);
+                    } else {
+                        formats_by_category[create_format_properties_chain_info.format_name].push_back(*existing_format);
+                    }
+                }
+            }
+
+            video_format_props.clear();
+            video_format_props_chains.clear();
+        }
+    }
+};
+
+struct AppDisplayPlane {
+    uint32_t global_index;
+    std::string name;
+    VkDisplayPlanePropertiesKHR properties;
+    std::vector<VkDisplayKHR> supported_displays;
+
+    AppDisplayPlane(AppGpu &gpu, uint32_t index, const VkDisplayPlanePropertiesKHR &in_prop);
+};
+
+struct AppDisplayMode {
+    VkDisplayModePropertiesKHR properties;
+
+    // key is a AppDisplayPlane::global_index value
+    std::map<uint32_t, VkDisplayPlaneCapabilitiesKHR> capabilities;
+
+    AppDisplayMode(AppGpu &gpu, const VkDisplayModePropertiesKHR &in_prop, const std::set<uint32_t> &supported_planes);
+};
+
+struct AppDisplay {
+    uint32_t global_index;
+
+    std::string name;
+
+    VkDisplayPropertiesKHR properties;
+    std::vector<AppDisplayMode> modes;
+
+    AppDisplay(AppGpu &gpu, uint32_t index, const VkDisplayPropertiesKHR &in_properties,
+               const std::vector<AppDisplayPlane> &all_planes);
+};
+
+class APIVersion {
+  public:
+    APIVersion() : api_version_(VK_API_VERSION_1_0) {}
+    APIVersion(uint32_t api_version) : api_version_(api_version) {}
+    void SetPatch(uint32_t patch) { api_version_ = api_version_ - Patch() + VK_API_VERSION_PATCH(patch); }
+    uint32_t Major() const { return VK_API_VERSION_MAJOR(api_version_); }
+    uint32_t Minor() const { return VK_API_VERSION_MINOR(api_version_); }
+    uint32_t Patch() const { return VK_API_VERSION_PATCH(api_version_); }
+    bool operator<(APIVersion api_version) const { return api_version_ < api_version.api_version_; }
+    bool operator<=(APIVersion api_version) const { return api_version_ <= api_version.api_version_; }
+    bool operator>(APIVersion api_version) const { return api_version_ > api_version.api_version_; }
+    bool operator>=(APIVersion api_version) const { return api_version_ >= api_version.api_version_; }
+    bool operator==(APIVersion api_version) const { return api_version_ == api_version.api_version_; }
+    bool operator!=(APIVersion api_version) const { return api_version_ != api_version.api_version_; }
+    std::string str() { return std::to_string(Major()) + "." + std::to_string(Minor()) + "." + std::to_string(Patch()); }
+    operator std::string() { return str(); }
+
+  private:
+    uint32_t api_version_;
+};
+
+std::ostream &operator<<(std::ostream &out, const APIVersion &v) {
+    return out << v.Major() << "." << v.Minor() << "." << v.Patch();
+}
+
+struct AppInstance {
+    VkInstance instance;
+    APIVersion api_version;
+
+    VkDebugReportCallbackEXT debug_callback = VK_NULL_HANDLE;
+
+    std::vector<LayerExtensionList> global_layers;
+
+    std::vector<VkExtensionProperties> global_extensions;  // Instance Extensions
+
+    std::vector<std::string> inst_extensions;
+
+    std::vector<SurfaceExtension> surface_extensions;
+
+    int width = 256, height = 256;
+
+    VkSurfaceCapabilitiesKHR surface_capabilities;
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    HINSTANCE h_instance;  // Windows Instance
+    HWND h_wnd;            // window handle
+#endif
+#ifdef VK_USE_PLATFORM_XCB_KHR
+    xcb_connection_t *xcb_connection;
+    xcb_screen_t *xcb_screen;
+    xcb_window_t xcb_window;
+#endif
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+    Display *xlib_display;
+    Window xlib_window;
+#endif
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+    void *macos_window;
+#endif
+#ifdef VK_USE_PLATFORM_METAL_EXT
+    void *metal_window;
+#endif
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+    wl_display *wayland_display;
+    wl_surface *wayland_surface;
+#endif
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+    IDirectFB *dfb;
+    IDirectFBSurface *directfb_surface;
+#endif
+#ifdef VK_USE_PLATFORM_ANDROID_KHR  // TODO
+    ANativeWindow *window;
+#endif
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+    struct _screen_context *context;
+    struct _screen_window *window;
+#endif
+    AppInstance() {
+        VkResult dllErr = load_vulkan_library();
+
+        if (dllErr != VK_SUCCESS) {
+            THROW_ERR("Failed to initialize: " API_NAME " loader is not installed, not found, or failed to load.");
+        }
+
+        uint32_t instance_version = VK_API_VERSION_1_0;
+        if (vkEnumerateInstanceVersion) {
+            const VkResult err = vkEnumerateInstanceVersion(&instance_version);
+            if (err) THROW_VK_ERR("vkEnumerateInstanceVersion", err);
+        }
+
+        api_version = APIVersion(instance_version);
+        // fallback to baked header version if loader returns 0 for the patch version
+        if (api_version.Patch() == 0) api_version.SetPatch(VK_HEADER_VERSION);
+
+        AppGetInstanceExtensions();
+
+        const VkDebugReportCallbackCreateInfoEXT dbg_info = {VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, nullptr,
+                                                             VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT,
+                                                             DbgCallback};
+
+        const VkApplicationInfo app_info = {
+            VK_STRUCTURE_TYPE_APPLICATION_INFO, nullptr, APP_SHORT_NAME, 1, nullptr, 0, instance_version};
+
+        AppCompileInstanceExtensionsToEnable();
+
+        std::vector<const char *> inst_exts;
+        for (const auto &ext : inst_extensions) {
+            inst_exts.push_back(ext.c_str());
+        }
+
+        const VkInstanceCreateInfo inst_info = {
+            VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
+            &dbg_info,
+            (CheckExtensionEnabled(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME)
+                 ? static_cast<VkInstanceCreateFlags>(VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR)
+                 : 0),
+            &app_info,
+            0,
+            nullptr,
+            static_cast<uint32_t>(inst_exts.size()),
+            inst_exts.data()};
+
+        VkResult err = vkCreateInstance(&inst_info, nullptr, &instance);
+        if (err == VK_ERROR_INCOMPATIBLE_DRIVER) {
+            std::cerr << "Cannot create " API_NAME " instance.\n";
+            std::cerr << "This problem is often caused by a faulty installation of the " API_NAME
+                         " driver or attempting to use a GPU "
+                         "that does not support " API_NAME ".\n";
+            THROW_VK_ERR("vkCreateInstance", err);
+        } else if (err) {
+            THROW_VK_ERR("vkCreateInstance", err);
+        }
+
+        load_vulkan_instance_functions(instance);
+
+        err = vkCreateDebugReportCallbackEXT(instance, &dbg_info, nullptr, &debug_callback);
+        if (err != VK_SUCCESS) {
+            THROW_VK_ERR("vkCreateDebugReportCallbackEXT", err);
+        }
+    }
+
+    ~AppInstance() {
+        if (debug_callback) vkDestroyDebugReportCallbackEXT(instance, debug_callback, nullptr);
+        if (vkDestroyInstance) vkDestroyInstance(instance, nullptr);
+        unload_vulkan_library();
+    }
+
+    AppInstance(const AppInstance &) = delete;
+    const AppInstance &operator=(const AppInstance &) = delete;
+
+    bool CheckExtensionEnabled(std::string extension_to_check) const {
+        return std::any_of(inst_extensions.begin(), inst_extensions.end(),
+                           [extension_to_check](std::string str) { return str == extension_to_check; });
+    }
+
+    /* Gets a list of layer and instance extensions */
+    void AppGetInstanceExtensions() {
+        /* Scan layers */
+        auto global_layer_properties =
+            GetVector<VkLayerProperties>("vkEnumerateInstanceLayerProperties", vkEnumerateInstanceLayerProperties);
+
+        for (const auto &layer : global_layer_properties) {
+            global_layers.push_back(LayerExtensionList{layer, AppGetGlobalLayerExtensions(layer.layerName)});
+        }
+
+        // Collect global extensions
+        // Gets instance extensions, if no layer was specified in the first paramteter
+        global_extensions = AppGetGlobalLayerExtensions(nullptr);
+    }
+    void AppCompileInstanceExtensionsToEnable() {
+#if defined(VK_USE_PLATFORM_MACOS_MVK) || defined(VK_USE_PLATFORM_IOS_MVK)
+        bool metal_surface_available = false;
+        for (const auto &ext : global_extensions) {
+            if (strcmp("VK_EXT_metal_surface", ext.extensionName) == 0) {
+                metal_surface_available = true;
+            }
+        }
+#endif
+
+        for (const auto &ext : global_extensions) {
+            if (strcmp(VK_EXT_DEBUG_REPORT_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+            if (strcmp(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+            if (strcmp(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+            if (strcmp(VK_KHR_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+            if (strcmp(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+            if (strcmp(VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_IOS_MVK
+            if (strcmp(VK_MVK_IOS_SURFACE_EXTENSION_NAME, ext.extensionName) == 0 && !metal_surface_available) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+            if (strcmp(VK_MVK_MACOS_SURFACE_EXTENSION_NAME, ext.extensionName) == 0 && !metal_surface_available) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_METAL_EXT
+            if (strcmp(VK_EXT_METAL_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_VI_NN
+            if (strcmp(VK_NN_VI_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+            if (strcmp(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+            if (strcmp(VK_KHR_WIN32_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_XCB_KHR
+            if (strcmp(VK_KHR_XCB_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+            if (strcmp(VK_KHR_XLIB_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+            if (strcmp(VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_GGP
+            if (strcmp(VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+            if (strcmp(VK_QNX_SCREEN_SURFACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+#ifdef VK_USE_PLATFORM_DISPLAY
+            if (strcmp(VK_KHR_DISPLAY_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+#endif
+            if (strcmp(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+            if (strcmp(VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+            if (strcmp(VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+            if (strcmp(VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME, ext.extensionName) == 0) {
+                inst_extensions.push_back(ext.extensionName);
+            }
+        }
+    }
+
+    void AddSurfaceExtension(SurfaceExtension ext) { surface_extensions.push_back(ext); }
+
+    std::vector<VkExtensionProperties> AppGetGlobalLayerExtensions(const char *layer_name) {
+        return GetVector<VkExtensionProperties>("vkEnumerateInstanceExtensionProperties", vkEnumerateInstanceExtensionProperties,
+                                                layer_name);
+    }
+
+    std::vector<VkPhysicalDevice> FindPhysicalDevices() {
+        return GetVector<VkPhysicalDevice>("vkEnumeratePhysicalDevices", vkEnumeratePhysicalDevices, instance);
+    }
+
+    std::vector<VkExtensionProperties> AppGetPhysicalDeviceLayerExtensions(VkPhysicalDevice phys_device, const char *layer_name) {
+        return GetVector<VkExtensionProperties>("vkEnumerateDeviceExtensionProperties", vkEnumerateDeviceExtensionProperties,
+                                                phys_device, layer_name);
+    }
+};
+
+// --------- Platform Specific Presentation Calls --------- //
+
+#if defined(VK_USE_PLATFORM_XCB_KHR) || defined(VK_USE_PLATFORM_XLIB_KHR) || defined(VK_USE_PLATFORM_WIN32_KHR) ||      \
+    defined(VK_USE_PLATFORM_MACOS_MVK) || defined(VK_USE_PLATFORM_METAL_EXT) || defined(VK_USE_PLATFORM_WAYLAND_KHR) || \
+    defined(VK_USE_PLATFORM_DIRECTFB_EXT) || defined(VK_USE_PLATFORM_GGP) || defined(VK_USE_PLATFORM_SCREEN_QNX) ||     \
+    defined(VK_USE_PLATFORM_DISPLAY)
+
+#define VULKANINFO_WSI_ENABLED
+#endif
+
+//-----------------------------------------------------------
+#if defined(VULKANINFO_WSI_ENABLED)
+static void AppDestroySurface(AppInstance &inst, VkSurfaceKHR surface) {  // same for all platforms
+    vkDestroySurfaceKHR(inst.instance, surface, nullptr);
+}
+#endif  // defined(VULKANINFO_WSI_ENABLED)
+//-----------------------------------------------------------
+
+//---------------------------Win32---------------------------
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+// MS-Windows event handling function:
+LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
+    return user32_handles->pfnDefWindowProcA(hWnd, uMsg, wParam, lParam);
+}
+
+static void AppCreateWin32Window(AppInstance &inst) {
+    inst.h_instance = GetModuleHandle(nullptr);
+
+    WNDCLASSEX win_class;
+
+    // Initialize the window class structure:
+    win_class.cbSize = sizeof(WNDCLASSEX);
+    win_class.style = CS_HREDRAW | CS_VREDRAW;
+    win_class.lpfnWndProc = WndProc;
+    win_class.cbClsExtra = 0;
+    win_class.cbWndExtra = 0;
+    win_class.hInstance = inst.h_instance;
+    win_class.hIcon = user32_handles->pfnLoadIconA(nullptr, IDI_APPLICATION);
+    win_class.hCursor = LoadCursor(nullptr, IDC_ARROW);
+    win_class.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
+    win_class.lpszMenuName = nullptr;
+    win_class.lpszClassName = APP_SHORT_NAME;
+    win_class.hInstance = inst.h_instance;
+    win_class.hIconSm = user32_handles->pfnLoadIconA(nullptr, IDI_WINLOGO);
+    // Register window class:
+    if (!user32_handles->pfnRegisterClassExA(&win_class)) {
+        // It didn't work, so try to give a useful error:
+        THROW_ERR("Failed to register the window class!");
+    }
+    // Create window with the registered class:
+    RECT wr = {0, 0, inst.width, inst.height};
+    user32_handles->pfnAdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);
+    inst.h_wnd = user32_handles->pfnCreateWindowExA(0,
+                                                    APP_SHORT_NAME,  // class name
+                                                    APP_SHORT_NAME,  // app name
+                                                    // WS_VISIBLE | WS_SYSMENU |
+                                                    WS_OVERLAPPEDWINDOW,  // window style
+                                                    100, 100,             // x/y coords
+                                                    wr.right - wr.left,   // width
+                                                    wr.bottom - wr.top,   // height
+                                                    nullptr,              // handle to parent
+                                                    nullptr,              // handle to menu
+                                                    inst.h_instance,      // hInstance
+                                                    nullptr);             // no extra parameters
+    if (!inst.h_wnd) {
+        // It didn't work, so try to give a useful error:
+        THROW_ERR("Failed to create a window!");
+    }
+}
+
+static VkSurfaceKHR AppCreateWin32Surface(AppInstance &inst) {
+    VkWin32SurfaceCreateInfoKHR createInfo;
+    createInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
+    createInfo.pNext = nullptr;
+    createInfo.flags = 0;
+    createInfo.hinstance = inst.h_instance;
+    createInfo.hwnd = inst.h_wnd;
+
+    VkSurfaceKHR surface;
+    VkResult err = vkCreateWin32SurfaceKHR(inst.instance, &createInfo, nullptr, &surface);
+    if (err) THROW_VK_ERR("vkCreateWin32SurfaceKHR", err);
+    return surface;
+}
+
+static void AppDestroyWin32Window(AppInstance &inst) { user32_handles->pfnDestroyWindow(inst.h_wnd); }
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+//-----------------------------------------------------------
+
+//----------------------------XCB----------------------------
+#ifdef VK_USE_PLATFORM_XCB_KHR
+static void AppCreateXcbWindow(AppInstance &inst) {
+    //--Init Connection--
+    const xcb_setup_t *setup;
+    xcb_screen_iterator_t iter;
+    int scr;
+
+    // API guarantees non-null xcb_connection
+    inst.xcb_connection = xcb_connect(nullptr, &scr);
+    int conn_error = xcb_connection_has_error(inst.xcb_connection);
+    if (conn_error) {
+        fprintf(stderr, "XCB failed to connect to the X server due to error:%d.\n", conn_error);
+        fflush(stderr);
+        xcb_disconnect(inst.xcb_connection);
+        inst.xcb_connection = nullptr;
+        return;
+    }
+
+    setup = xcb_get_setup(inst.xcb_connection);
+    iter = xcb_setup_roots_iterator(setup);
+    while (scr-- > 0) {
+        xcb_screen_next(&iter);
+    }
+
+    inst.xcb_screen = iter.data;
+    //-------------------
+
+    inst.xcb_window = xcb_generate_id(inst.xcb_connection);
+    xcb_create_window(inst.xcb_connection, XCB_COPY_FROM_PARENT, inst.xcb_window, inst.xcb_screen->root, 0, 0, inst.width,
+                      inst.height, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, inst.xcb_screen->root_visual, 0, nullptr);
+
+    xcb_intern_atom_cookie_t cookie = xcb_intern_atom(inst.xcb_connection, 1, 12, "WM_PROTOCOLS");
+    xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(inst.xcb_connection, cookie, 0);
+    free(reply);
+}
+
+static VkSurfaceKHR AppCreateXcbSurface(AppInstance &inst) {
+    if (!inst.xcb_connection) {
+        THROW_ERR("AppCreateXcbSurface failed to establish connection");
+    }
+
+    VkXcbSurfaceCreateInfoKHR xcb_createInfo;
+    xcb_createInfo.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
+    xcb_createInfo.pNext = nullptr;
+    xcb_createInfo.flags = 0;
+    xcb_createInfo.connection = inst.xcb_connection;
+    xcb_createInfo.window = inst.xcb_window;
+
+    VkSurfaceKHR surface;
+    VkResult err = vkCreateXcbSurfaceKHR(inst.instance, &xcb_createInfo, nullptr, &surface);
+    if (err) THROW_VK_ERR("vkCreateXcbSurfaceKHR", err);
+    return surface;
+}
+
+static void AppDestroyXcbWindow(AppInstance &inst) {
+    if (!inst.xcb_connection) {
+        return;  // Nothing to destroy
+    }
+
+    xcb_destroy_window(inst.xcb_connection, inst.xcb_window);
+    xcb_disconnect(inst.xcb_connection);
+}
+#endif  // VK_USE_PLATFORM_XCB_KHR
+//-----------------------------------------------------------
+
+//----------------------------XLib---------------------------
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+static void AppCreateXlibWindow(AppInstance &inst) {
+    long visualMask = VisualScreenMask;
+    int numberOfVisuals{};
+
+    inst.xlib_display = XOpenDisplay(nullptr);
+    if (inst.xlib_display == nullptr) {
+        THROW_ERR("XLib failed to connect to the X server.\nExiting...");
+    }
+
+    XVisualInfo vInfoTemplate = {};
+    vInfoTemplate.screen = DefaultScreen(inst.xlib_display);
+    XVisualInfo *visualInfoBegin = XGetVisualInfo(inst.xlib_display, visualMask, &vInfoTemplate, &numberOfVisuals);
+    XVisualInfo *visualInfoEnd = visualInfoBegin + numberOfVisuals;
+    const Visual *rootVisual = DefaultVisual(inst.xlib_display, vInfoTemplate.screen);
+    const XVisualInfo *foundVisualInfo =
+        std::find_if(visualInfoBegin, visualInfoEnd, [rootVisual](const XVisualInfo &vi) { return vi.visual == rootVisual; });
+    const XVisualInfo *visualInfo = foundVisualInfo == visualInfoEnd ? visualInfoBegin : foundVisualInfo;
+    inst.xlib_window = XCreateWindow(inst.xlib_display, RootWindow(inst.xlib_display, vInfoTemplate.screen), 0, 0, inst.width,
+                                     inst.height, 0, visualInfo->depth, InputOutput, visualInfo->visual, 0, nullptr);
+
+    XSync(inst.xlib_display, false);
+    XFree(visualInfoBegin);
+}
+
+static VkSurfaceKHR AppCreateXlibSurface(AppInstance &inst) {
+    VkXlibSurfaceCreateInfoKHR createInfo;
+    createInfo.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
+    createInfo.pNext = nullptr;
+    createInfo.flags = 0;
+    createInfo.dpy = inst.xlib_display;
+    createInfo.window = inst.xlib_window;
+
+    VkSurfaceKHR surface;
+    VkResult err = vkCreateXlibSurfaceKHR(inst.instance, &createInfo, nullptr, &surface);
+    if (err) THROW_VK_ERR("vkCreateXlibSurfaceKHR", err);
+    return surface;
+}
+
+static void AppDestroyXlibWindow(AppInstance &inst) {
+    XDestroyWindow(inst.xlib_display, inst.xlib_window);
+    XCloseDisplay(inst.xlib_display);
+}
+#endif  // VK_USE_PLATFORM_XLIB_KHR
+//-----------------------------------------------------------
+
+//------------------------MACOS_MVK--------------------------
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+static void AppCreateMacOSWindow(AppInstance &inst) {
+    inst.macos_window = CreateMetalView(inst.width, inst.height);
+    if (inst.macos_window == nullptr) {
+        THROW_ERR("Could not create a native Metal view.\nExiting...");
+    }
+}
+
+static VkSurfaceKHR AppCreateMacOSSurface(AppInstance &inst) {
+    VkMacOSSurfaceCreateInfoMVK createInfo;
+    createInfo.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
+    createInfo.pNext = nullptr;
+    createInfo.flags = 0;
+    createInfo.pView = inst.macos_window;
+
+    VkSurfaceKHR surface;
+    VkResult err = vkCreateMacOSSurfaceMVK(inst.instance, &createInfo, nullptr, &surface);
+    if (err) THROW_VK_ERR("vkCreateMacOSSurfaceMVK", err);
+    return surface;
+}
+
+static void AppDestroyMacOSWindow(AppInstance &inst) { DestroyMetalView(inst.macos_window); }
+#endif  // VK_USE_PLATFORM_MACOS_MVK
+//-----------------------------------------------------------
+
+//------------------------METAL_EXT--------------------------
+#ifdef VK_USE_PLATFORM_METAL_EXT
+static void AppCreateMetalWindow(AppInstance &inst) {
+    inst.metal_window = CreateMetalView(inst.width, inst.height);
+    if (inst.metal_window == nullptr) {
+        THROW_ERR("Could not create a native Metal view.\nExiting...");
+    }
+}
+
+static VkSurfaceKHR AppCreateMetalSurface(AppInstance &inst) {
+    VkMetalSurfaceCreateInfoEXT createInfo;
+    createInfo.sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT;
+    createInfo.pNext = nullptr;
+    createInfo.flags = 0;
+    createInfo.pLayer = static_cast<CAMetalLayer *>(GetCAMetalLayerFromMetalView(inst.metal_window));
+
+    VkSurfaceKHR surface;
+    VkResult err = vkCreateMetalSurfaceEXT(inst.instance, &createInfo, nullptr, &surface);
+    if (err) THROW_VK_ERR("vkCreateMetalSurfaceEXT", err);
+    return surface;
+}
+
+static void AppDestroyMetalWindow(AppInstance &inst) { DestroyMetalView(inst.metal_window); }
+#endif  // VK_USE_PLATFORM_METAL_EXT
+//-----------------------------------------------------------
+
+//-------------------------WAYLAND---------------------------
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+static void wayland_registry_global(void *data, struct wl_registry *registry, uint32_t id, const char *interface,
+                                    uint32_t version) {
+    AppInstance &inst = *static_cast<AppInstance *>(data);
+    if (strcmp(interface, "wl_compositor") == 0) {
+        struct wl_compositor *compositor = (struct wl_compositor *)wl_registry_bind(registry, id, &wl_compositor_interface, 1);
+        inst.wayland_surface = wl_compositor_create_surface(compositor);
+    }
+}
+static void wayland_registry_global_remove(void *data, struct wl_registry *registry, uint32_t id) {}
+static const struct wl_registry_listener wayland_registry_listener = {wayland_registry_global, wayland_registry_global_remove};
+
+static void AppCreateWaylandWindow(AppInstance &inst) {
+    inst.wayland_display = wl_display_connect(nullptr);
+    struct wl_registry *registry = wl_display_get_registry(inst.wayland_display);
+    wl_registry_add_listener(wl_display_get_registry(inst.wayland_display), &wayland_registry_listener, static_cast<void *>(&inst));
+    wl_display_roundtrip(inst.wayland_display);
+    wl_registry_destroy(registry);
+}
+
+static VkSurfaceKHR AppCreateWaylandSurface(AppInstance &inst) {
+    VkWaylandSurfaceCreateInfoKHR createInfo;
+    createInfo.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
+    createInfo.pNext = nullptr;
+    createInfo.flags = 0;
+    createInfo.display = inst.wayland_display;
+    createInfo.surface = inst.wayland_surface;
+
+    VkSurfaceKHR surface;
+    VkResult err = vkCreateWaylandSurfaceKHR(inst.instance, &createInfo, nullptr, &surface);
+    if (err) THROW_VK_ERR("vkCreateWaylandSurfaceKHR", err);
+    return surface;
+}
+
+static void AppDestroyWaylandWindow(AppInstance &inst) { wl_display_disconnect(inst.wayland_display); }
+#endif  // VK_USE_PLATFORM_WAYLAND_KHR
+//-----------------------------------------------------------
+
+//-------------------------DIRECTFB--------------------------
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+static void AppCreateDirectFBWindow(AppInstance &inst) {
+    DFBResult ret;
+
+    ret = DirectFBInit(NULL, NULL);
+    if (ret) {
+        THROW_ERR("DirectFBInit failed to initialize DirectFB.\nExiting...");
+    }
+
+    ret = DirectFBCreate(&inst.dfb);
+    if (ret) {
+        THROW_ERR("DirectFBCreate failed to create main interface of DirectFB.\nExiting...");
+    }
+
+    DFBSurfaceDescription desc;
+    desc.flags = (DFBSurfaceDescriptionFlags)(DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT);
+    desc.caps = DSCAPS_PRIMARY;
+    desc.width = inst.width;
+    desc.height = inst.height;
+    ret = inst.dfb->CreateSurface(inst.dfb, &desc, &inst.directfb_surface);
+    if (ret) {
+        THROW_ERR("CreateSurface failed to create DirectFB surface interface.\nExiting...");
+    }
+}
+
+static VkSurfaceKHR AppCreateDirectFBSurface(AppInstance &inst) {
+    VkDirectFBSurfaceCreateInfoEXT createInfo;
+    createInfo.sType = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT;
+    createInfo.pNext = nullptr;
+    createInfo.flags = 0;
+    createInfo.dfb = inst.dfb;
+    createInfo.surface = inst.directfb_surface;
+
+    VkSurfaceKHR surface;
+    VkResult err = vkCreateDirectFBSurfaceEXT(inst.instance, &createInfo, nullptr, &surface);
+    if (err) THROW_VK_ERR("vkCreateDirectFBSurfaceEXT", err);
+    return surface;
+}
+
+static void AppDestroyDirectFBWindow(AppInstance &inst) {
+    inst.directfb_surface->Release(inst.directfb_surface);
+    inst.dfb->Release(inst.dfb);
+}
+#endif  // VK_USE_PLATFORM_DIRECTFB_EXT
+//-----------------------------------------------------------
+
+//-------------------------ANDROID---------------------------
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+static void AppCreateAndroidWindow(AppInstance &inst) {}
+static VkSurfaceKHR AppCreateAndroidSurface(AppInstance &inst) {
+    VkAndroidSurfaceCreateInfoKHR createInfo;
+    createInfo.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
+    createInfo.pNext = NULL;
+    createInfo.flags = 0;
+    createInfo.window = (struct ANativeWindow *)(inst.window);
+
+    VkSurfaceKHR surface;
+    VkResult err = vkCreateAndroidSurfaceKHR(inst.instance, &createInfo, NULL, &surface);
+    if (err) THROW_VK_ERR("vkCreateAndroidSurfaceKHR", err);
+    return surface;
+}
+static void AppDestroyAndroidWindow(AppInstance &inst) {}
+#endif
+//-----------------------------------------------------------
+//---------------------------GGP-----------------------------
+#ifdef VK_USE_PLATFORM_GGP
+static void AppCreateGgpWindow(AppInstance &inst) {}
+static VkSurfaceKHR AppCreateGgpSurface(AppInstance &inst) {
+    VkStreamDescriptorSurfaceCreateInfoGGP createInfo;
+    createInfo.sType = VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP;
+    createInfo.pNext = NULL;
+    createInfo.flags = 0;
+    createInfo.streamDescriptor = 1;
+
+    VkSurfaceKHR surface;
+    VkResult err = vkCreateStreamDescriptorSurfaceGGP(inst.instance, &createInfo, NULL, &surface);
+    if (err) THROW_VK_ERR("vkCreateStreamDescriptorSurfaceGGP", err);
+    return surface;
+}
+static void AppDestroyGgpWindow(AppInstance &inst) {}
+#endif
+//-----------------------------------------------------------
+//----------------------QNX SCREEN---------------------------
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+static void AppCreateScreenWindow(AppInstance &inst) {
+    int usage = SCREEN_USAGE_VULKAN;
+    int rc;
+
+    rc = screen_create_context(&inst.context, 0);
+    if (rc) {
+        THROW_ERR("Could not create a QNX Screen context.\nExiting...");
+    }
+    rc = screen_create_window(&inst.window, inst.context);
+    if (rc) {
+        THROW_ERR("Could not create a QNX Screen window.\nExiting...");
+    }
+    rc = screen_set_window_property_iv(inst.window, SCREEN_PROPERTY_USAGE, &usage);
+    if (rc) {
+        THROW_ERR("Could not set SCREEN_USAGE_VULKAN flag for QNX Screen window!\nExiting...");
+    }
+}
+
+static VkSurfaceKHR AppCreateScreenSurface(AppInstance &inst) {
+    VkScreenSurfaceCreateInfoQNX createInfo;
+    createInfo.sType = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX;
+    createInfo.pNext = nullptr;
+    createInfo.flags = 0;
+    createInfo.context = inst.context;
+    createInfo.window = inst.window;
+
+    VkSurfaceKHR surface;
+    VkResult err = vkCreateScreenSurfaceQNX(inst.instance, &createInfo, nullptr, &surface);
+    if (err) THROW_VK_ERR("vkCreateScreenSurfaceQNX", err);
+    return surface;
+}
+
+static void AppDestroyScreenWindow(AppInstance &inst) {
+    screen_destroy_window(inst.window);
+    screen_destroy_context(inst.context);
+}
+#endif  // VK_USE_PLATFORM_SCREEN_QNX
+//-----------------------------------------------------------
+// ------------ Setup Windows ------------- //
+
+void SetupWindowExtensions(AppInstance &inst) {
+#if defined(VK_USE_PLATFORM_XCB_KHR) || defined(VK_USE_PLATFORM_XLIB_KHR)
+    bool has_display = true;
+    const char *display_var = getenv("DISPLAY");
+    if (display_var == nullptr || strlen(display_var) == 0) {
+        has_display = false;
+        std::cerr << "'DISPLAY' environment variable not set... skipping surface info\n";
+    }
+#endif
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+    wl_display *wayland_display = wl_display_connect(nullptr);
+    bool has_wayland_display = false;
+    if (wayland_display != nullptr) {
+        wl_display_disconnect(wayland_display);
+        has_wayland_display = true;
+    }
+#endif
+
+//--WIN32--
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    SurfaceExtension surface_ext_win32;
+    if (inst.CheckExtensionEnabled(VK_KHR_WIN32_SURFACE_EXTENSION_NAME)) {
+        surface_ext_win32.name = VK_KHR_WIN32_SURFACE_EXTENSION_NAME;
+        surface_ext_win32.create_window = AppCreateWin32Window;
+        surface_ext_win32.create_surface = AppCreateWin32Surface;
+        surface_ext_win32.destroy_window = AppDestroyWin32Window;
+
+        inst.AddSurfaceExtension(surface_ext_win32);
+    }
+#endif
+//--XCB--
+#ifdef VK_USE_PLATFORM_XCB_KHR
+    SurfaceExtension surface_ext_xcb;
+    if (inst.CheckExtensionEnabled(VK_KHR_XCB_SURFACE_EXTENSION_NAME)) {
+        surface_ext_xcb.name = VK_KHR_XCB_SURFACE_EXTENSION_NAME;
+        surface_ext_xcb.create_window = AppCreateXcbWindow;
+        surface_ext_xcb.create_surface = AppCreateXcbSurface;
+        surface_ext_xcb.destroy_window = AppDestroyXcbWindow;
+        if (has_display) {
+            inst.AddSurfaceExtension(surface_ext_xcb);
+        }
+    }
+#endif
+//--XLIB--
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+    SurfaceExtension surface_ext_xlib;
+    if (inst.CheckExtensionEnabled(VK_KHR_XLIB_SURFACE_EXTENSION_NAME)) {
+        surface_ext_xlib.name = VK_KHR_XLIB_SURFACE_EXTENSION_NAME;
+        surface_ext_xlib.create_window = AppCreateXlibWindow;
+        surface_ext_xlib.create_surface = AppCreateXlibSurface;
+        surface_ext_xlib.destroy_window = AppDestroyXlibWindow;
+        if (has_display) {
+            inst.AddSurfaceExtension(surface_ext_xlib);
+        }
+    }
+#endif
+//--MACOS--
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+    SurfaceExtension surface_ext_macos;
+    if (inst.CheckExtensionEnabled(VK_MVK_MACOS_SURFACE_EXTENSION_NAME) && !inst.CheckExtensionEnabled("VK_EXT_metal_surface")) {
+        surface_ext_macos.name = VK_MVK_MACOS_SURFACE_EXTENSION_NAME;
+        surface_ext_macos.create_window = AppCreateMacOSWindow;
+        surface_ext_macos.create_surface = AppCreateMacOSSurface;
+        surface_ext_macos.destroy_window = AppDestroyMacOSWindow;
+
+        inst.AddSurfaceExtension(surface_ext_macos);
+    }
+#endif
+
+#ifdef VK_USE_PLATFORM_METAL_EXT
+    SurfaceExtension surface_ext_metal;
+    if (inst.CheckExtensionEnabled(VK_EXT_METAL_SURFACE_EXTENSION_NAME)) {
+        surface_ext_metal.name = VK_EXT_METAL_SURFACE_EXTENSION_NAME;
+        surface_ext_metal.create_window = AppCreateMetalWindow;
+        surface_ext_metal.create_surface = AppCreateMetalSurface;
+        surface_ext_metal.destroy_window = AppDestroyMetalWindow;
+
+        inst.AddSurfaceExtension(surface_ext_metal);
+    }
+#endif
+//--WAYLAND--
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+    SurfaceExtension surface_ext_wayland;
+    if (inst.CheckExtensionEnabled(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME)) {
+        surface_ext_wayland.name = VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME;
+        surface_ext_wayland.create_window = AppCreateWaylandWindow;
+        surface_ext_wayland.create_surface = AppCreateWaylandSurface;
+        surface_ext_wayland.destroy_window = AppDestroyWaylandWindow;
+        if (has_wayland_display) {
+            inst.AddSurfaceExtension(surface_ext_wayland);
+        }
+    }
+#endif
+//--DIRECTFB--
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+    SurfaceExtension surface_ext_directfb;
+    if (inst.CheckExtensionEnabled(VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME)) {
+        surface_ext_directfb.name = VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME;
+        surface_ext_directfb.create_window = AppCreateDirectFBWindow;
+        surface_ext_directfb.create_surface = AppCreateDirectFBSurface;
+        surface_ext_directfb.destroy_window = AppDestroyDirectFBWindow;
+
+        inst.AddSurfaceExtension(surface_ext_directfb);
+    }
+#endif
+//--ANDROID--
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+    SurfaceExtension surface_ext_android;
+    if (inst.CheckExtensionEnabled(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME)) {
+        surface_ext_android.name = VK_KHR_ANDROID_SURFACE_EXTENSION_NAME;
+        surface_ext_android.create_window = AppCreateAndroidWindow;
+        surface_ext_android.create_surface = AppCreateAndroidSurface;
+        surface_ext_android.destroy_window = AppDestroyAndroidWindow;
+
+        inst.AddSurfaceExtension(surface_ext_android);
+    }
+#endif
+//--GGP--
+#ifdef VK_USE_PLATFORM_GGP
+    SurfaceExtension surface_ext_ggp;
+    if (inst.CheckExtensionEnabled(VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME)) {
+        surface_ext_ggp.name = VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME;
+        surface_ext_ggp.create_window = AppCreateGgpWindow;
+        surface_ext_ggp.create_surface = AppCreateGgpSurface;
+        surface_ext_ggp.destroy_window = AppDestroyGgpWindow;
+
+        inst.AddSurfaceExtension(surface_ext_ggp);
+    }
+#endif
+//--QNX_SCREEN--
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+    SurfaceExtension surface_ext_qnx_screen;
+    if (inst.CheckExtensionEnabled(VK_QNX_SCREEN_SURFACE_EXTENSION_NAME)) {
+        surface_ext_qnx_screen.name = VK_QNX_SCREEN_SURFACE_EXTENSION_NAME;
+        surface_ext_qnx_screen.create_window = AppCreateScreenWindow;
+        surface_ext_qnx_screen.create_surface = AppCreateScreenSurface;
+        surface_ext_qnx_screen.destroy_window = AppDestroyScreenWindow;
+
+        inst.AddSurfaceExtension(surface_ext_qnx_screen);
+    }
+#endif
+// TODO: add support for VK_KHR_display surfaces
+}
+
+// ---------- Surfaces -------------- //
+
+class AppSurface {
+  public:
+    AppInstance &inst;
+    VkPhysicalDevice phys_device;
+    SurfaceExtension surface_extension;
+
+    std::vector<VkPresentModeKHR> surf_present_modes;
+
+    std::vector<VkSurfaceFormatKHR> surf_formats;
+    std::vector<VkSurfaceFormat2KHR> surf_formats2;
+
+    VkSurfaceCapabilitiesKHR surface_capabilities{};
+    VkSurfaceCapabilities2KHR surface_capabilities2_khr{};
+    VkSurfaceCapabilities2EXT surface_capabilities2_ext{};
+
+    std::unique_ptr<surface_capabilities2_chain> chain_for_surface_capabilities2;
+
+    AppSurface(AppInstance &inst, AppGpu &gpu, VkPhysicalDevice phys_device, SurfaceExtension surface_extension)
+        : inst(inst), phys_device(phys_device), surface_extension(surface_extension) {
+        surf_present_modes =
+            GetVector<VkPresentModeKHR>("vkGetPhysicalDeviceSurfacePresentModesKHR", vkGetPhysicalDeviceSurfacePresentModesKHR,
+                                        phys_device, surface_extension.surface);
+
+        if (inst.CheckExtensionEnabled(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME)) {
+            const VkPhysicalDeviceSurfaceInfo2KHR surface_info2 = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, nullptr,
+                                                                   surface_extension.surface};
+            VkSurfaceFormat2KHR init{};
+            init.sType = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR;
+            surf_formats2 = GetVectorInit<VkSurfaceFormat2KHR>(
+                "vkGetPhysicalDeviceSurfaceFormats2KHR", vkGetPhysicalDeviceSurfaceFormats2KHR, init, phys_device, &surface_info2);
+        } else {
+            surf_formats =
+                GetVector<VkSurfaceFormatKHR>("vkGetPhysicalDeviceSurfaceFormatsKHR", vkGetPhysicalDeviceSurfaceFormatsKHR,
+                                              phys_device, surface_extension.surface);
+        }
+
+        if (inst.CheckExtensionEnabled(VK_KHR_SURFACE_EXTENSION_NAME)) {
+            VkResult err = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(phys_device, surface_extension.surface, &surface_capabilities);
+            if (err) THROW_VK_ERR("vkGetPhysicalDeviceSurfaceCapabilitiesKHR", err);
+        }
+
+        if (inst.CheckExtensionEnabled(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME)) {
+            surface_capabilities2_khr.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR;
+            setup_surface_capabilities2_chain(surface_capabilities2_khr, chain_for_surface_capabilities2, inst, gpu);
+
+            VkPhysicalDeviceSurfaceInfo2KHR surface_info{};
+            surface_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
+            surface_info.surface = surface_extension.surface;
+#if defined(WIN32)
+            VkSurfaceFullScreenExclusiveWin32InfoEXT win32_fullscreen_exclusive_info{};
+            win32_fullscreen_exclusive_info.sType = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT;
+            win32_fullscreen_exclusive_info.hmonitor = MonitorFromWindow(inst.h_wnd, MONITOR_DEFAULTTOPRIMARY);
+
+            surface_info.pNext = static_cast<void *>(&win32_fullscreen_exclusive_info);
+#endif  // defined(WIN32)
+            VkResult err = vkGetPhysicalDeviceSurfaceCapabilities2KHR(phys_device, &surface_info, &surface_capabilities2_khr);
+            if (err) THROW_VK_ERR("vkGetPhysicalDeviceSurfaceCapabilities2KHR", err);
+        }
+
+        if (inst.CheckExtensionEnabled(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME)) {
+            surface_capabilities2_ext.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT;
+            surface_capabilities2_ext.pNext = nullptr;
+            VkResult err =
+                vkGetPhysicalDeviceSurfaceCapabilities2EXT(phys_device, surface_extension.surface, &surface_capabilities2_ext);
+            if (err) THROW_VK_ERR("vkGetPhysicalDeviceSurfaceCapabilities2EXT", err);
+        }
+    }
+
+    AppSurface(const AppSurface &) = delete;
+    const AppSurface &operator=(const AppSurface &) = delete;
+};
+
+// -------------------- Device Groups ------------------------//
+
+std::vector<VkPhysicalDeviceGroupProperties> GetGroups(AppInstance &inst) {
+    if (inst.CheckExtensionEnabled(VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME)) {
+        VkPhysicalDeviceGroupProperties group_props{};
+        group_props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES;
+        return GetVectorInit<VkPhysicalDeviceGroupProperties>("vkEnumeratePhysicalDeviceGroupsKHR",
+                                                              vkEnumeratePhysicalDeviceGroupsKHR, group_props, inst.instance);
+    }
+    return {};
+}
+
+std::vector<VkPhysicalDeviceProperties> GetGroupProps(AppInstance &inst, VkPhysicalDeviceGroupProperties group) {
+    std::vector<VkPhysicalDeviceProperties> props(group.physicalDeviceCount);
+
+    for (uint32_t i = 0; i < group.physicalDeviceCount; ++i) {
+        vkGetPhysicalDeviceProperties(group.physicalDevices[i], &props[i]);
+    }
+
+    return props;
+}
+
+util::vulkaninfo_optional<VkDeviceGroupPresentCapabilitiesKHR> GetGroupCapabilities(AppInstance &inst,
+                                                                                    VkPhysicalDeviceGroupProperties group) {
+    // Build create info for logical device made from all physical devices in this group.
+    std::vector<std::string> extensions_list = {VK_KHR_SWAPCHAIN_EXTENSION_NAME, VK_KHR_DEVICE_GROUP_EXTENSION_NAME};
+
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    for (const auto &extension : inst.AppGetPhysicalDeviceLayerExtensions(group.physicalDevices[0], nullptr)) {
+        if (std::string(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME) == extension.extensionName) {
+            extensions_list.push_back(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME);
+        }
+    }
+#endif
+
+    VkDeviceGroupDeviceCreateInfoKHR dg_ci = {VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR, nullptr,
+                                              group.physicalDeviceCount, group.physicalDevices};
+
+    float queue_priority = 1.0f;
+
+    auto ext_list = get_c_str_array(extensions_list);
+
+    VkDeviceQueueCreateInfo q_ci = {VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, nullptr, 0, 0, 1, &queue_priority};
+    VkDeviceCreateInfo device_ci = {VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,   &dg_ci,         0, 1, &q_ci, 0, nullptr,
+                                    static_cast<uint32_t>(ext_list.size()), ext_list.data()};
+
+    VkDevice logical_device = VK_NULL_HANDLE;
+
+    VkResult err = vkCreateDevice(group.physicalDevices[0], &device_ci, nullptr, &logical_device);
+    if (err != VK_SUCCESS && err != VK_ERROR_EXTENSION_NOT_PRESENT) THROW_VK_ERR("vkCreateDevice", err);
+
+    if (err == VK_ERROR_EXTENSION_NOT_PRESENT) {
+        vkDestroyDevice(logical_device, nullptr);
+        return {};
+    }
+
+    VkDeviceGroupPresentCapabilitiesKHR group_capabilities = {VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR, nullptr};
+
+    // If the KHR_device_group extension is present, write the capabilities of the logical device into a struct for later
+    // output to user.
+    err = vkGetDeviceGroupPresentCapabilitiesKHR(logical_device, &group_capabilities);
+    if (err) THROW_VK_ERR("vkGetDeviceGroupPresentCapabilitiesKHR", err);
+
+    vkDestroyDevice(logical_device, nullptr);
+
+    return {group_capabilities};
+}
+
+// -------------------- Device Setup ------------------- //
+
+const VkFormat color_format = VK_FORMAT_R8G8B8A8_UNORM;
+
+struct ImageTypeSupport {
+    enum class Type { regular, sparse, transient } type;
+    uint32_t memoryTypeBits;
+
+    bool Compatible(uint32_t memtype_bit) { return memoryTypeBits & memtype_bit; }
+};
+
+struct ImageTypeFormatInfo {
+    VkFormat format;
+    std::vector<ImageTypeSupport> type_support;
+};
+
+struct ImageTypeInfos {
+    VkImageTiling tiling;
+    std::vector<ImageTypeFormatInfo> formats;
+};
+
+VkImageCreateInfo GetImageCreateInfo(VkImageCreateFlags flags, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usages) {
+    return {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
+            nullptr,
+            flags,
+            VK_IMAGE_TYPE_2D,
+            format,
+            {8, 8, 1},
+            1,
+            1,
+            VK_SAMPLE_COUNT_1_BIT,
+            tiling,
+            usages,
+            VK_SHARING_MODE_EXCLUSIVE,
+            0,
+            nullptr,
+            VK_IMAGE_LAYOUT_UNDEFINED};
+}
+
+util::vulkaninfo_optional<ImageTypeSupport> FillImageTypeSupport(AppInstance &inst, VkPhysicalDevice phys_device, VkDevice device,
+                                                                 ImageTypeSupport::Type img_type, VkImageCreateInfo image_ci) {
+    VkImageFormatProperties img_props;
+    VkResult res = vkGetPhysicalDeviceImageFormatProperties(phys_device, image_ci.format, image_ci.imageType, image_ci.tiling,
+                                                            image_ci.usage, image_ci.flags, &img_props);
+
+    if (res == VK_SUCCESS) {
+        ImageTypeSupport img_type_support{};
+        img_type_support.type = img_type;
+
+        VkImage dummy_img;
+        res = vkCreateImage(device, &image_ci, nullptr, &dummy_img);
+        if (res) THROW_VK_ERR("vkCreateImage", res);
+
+        VkMemoryRequirements mem_req;
+        vkGetImageMemoryRequirements(device, dummy_img, &mem_req);
+        img_type_support.memoryTypeBits = mem_req.memoryTypeBits;
+
+        vkDestroyImage(device, dummy_img, nullptr);
+        return img_type_support;
+    } else if (res == VK_ERROR_FORMAT_NOT_SUPPORTED) {
+        return {};  // return empty util::vulkaninfo_optional
+    }
+    THROW_VK_ERR("vkGetPhysicalDeviceImageFormatProperties", res);
+    return {};
+}
+
+struct FormatRange {
+    // the Vulkan standard version that supports this format range, or 0 if non-standard
+    APIVersion minimum_instance_version;
+
+    // The name of the extension that supports this format range, or NULL if the range
+    // is only part of the standard
+    const char *extension_name;
+
+    // The first and last supported formats within this range.
+    VkFormat first_format;
+    VkFormat last_format;
+};
+
+struct AppQueueFamilyProperties {
+    VkQueueFamilyProperties props;
+    uint32_t queue_index;
+    void *pNext = nullptr;  // assumes the lifetime of the pNext chain outlives this object, eg parent object must keep both alive
+    bool can_present = false;
+    bool can_always_present = true;
+    std::vector<std::pair<std::string, VkBool32>> present_support;
+    AppQueueFamilyProperties(AppInstance &inst, VkPhysicalDevice physical_device, VkQueueFamilyProperties family_properties,
+                             uint32_t queue_index, void *pNext = nullptr)
+        : props(family_properties), queue_index(queue_index), pNext(pNext) {
+        for (const auto &surface_ext : inst.surface_extensions) {
+            present_support.push_back({surface_ext.name, VK_FALSE});
+            VkResult err = vkGetPhysicalDeviceSurfaceSupportKHR(physical_device, queue_index, surface_ext.surface,
+                                                                &present_support.back().second);
+            if (err) THROW_VK_ERR("vkGetPhysicalDeviceSurfaceSupportKHR", err);
+            if (present_support.back().second) {
+                can_present = true;
+            } else {
+                can_always_present = false;
+            }
+        }
+    }
+};
+
+struct AppGpu {
+    AppInstance &inst;
+    uint32_t id{};
+    VkPhysicalDevice phys_device = VK_NULL_HANDLE;
+    APIVersion api_version;
+
+    VkPhysicalDeviceProperties props{};
+    VkPhysicalDeviceProperties2KHR props2{};
+
+    // VkPhysicalDeviceDriverProperties
+    VkDriverId driverID;
+    char driverName[VK_MAX_DRIVER_NAME_SIZE];
+    char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
+    VkConformanceVersion conformanceVersion;
+    // VkPhysicalDeviceIDProperties
+    uint8_t deviceUUID[VK_UUID_SIZE];
+    uint8_t driverUUID[VK_UUID_SIZE];
+    uint8_t deviceLUID[VK_LUID_SIZE];
+    uint32_t deviceNodeMask;
+    VkBool32 deviceLUIDValid;
+
+    bool found_driver_props = false;
+    bool found_device_id_props = false;
+
+    std::vector<VkQueueFamilyProperties> queue_props;
+    std::vector<VkQueueFamilyProperties2KHR> queue_props2;
+    std::vector<AppQueueFamilyProperties> extended_queue_props;
+
+    VkPhysicalDeviceMemoryProperties memory_props{};
+    VkPhysicalDeviceMemoryProperties2KHR memory_props2{};
+
+    std::vector<ImageTypeInfos> memory_image_support_types;
+
+    VkPhysicalDeviceFeatures features{};
+    VkPhysicalDeviceFeatures2KHR features2{};
+
+    std::vector<VkExtensionProperties> device_extensions;
+
+    VkDevice dev = VK_NULL_HANDLE;
+    VkPhysicalDeviceFeatures enabled_features{};
+
+    std::array<VkDeviceSize, VK_MAX_MEMORY_HEAPS> heapBudget;
+    std::array<VkDeviceSize, VK_MAX_MEMORY_HEAPS> heapUsage;
+
+    std::unique_ptr<phys_device_props2_chain> chain_for_phys_device_props2;
+    std::unique_ptr<phys_device_mem_props2_chain> chain_for_phys_device_mem_props2;
+    std::unique_ptr<phys_device_features2_chain> chain_for_phys_device_features2;
+    std::vector<std::unique_ptr<queue_properties2_chain>> chain_for_queue_props2;
+
+    std::vector<std::unique_ptr<AppVideoProfile>> video_profiles;
+
+    std::vector<AppDisplay> displays;
+    std::vector<AppDisplayPlane> display_planes;
+
+    AppGpu(AppInstance &inst, uint32_t id, VkPhysicalDevice phys_device, bool show_promoted_structs)
+        : inst(inst), id(id), phys_device(phys_device) {
+        vkGetPhysicalDeviceProperties(phys_device, &props);
+
+        // needs to find the minimum of the instance and device version, and use that to print the device info
+        api_version = APIVersion(props.apiVersion);
+
+        device_extensions = inst.AppGetPhysicalDeviceLayerExtensions(phys_device, nullptr);
+
+        vkGetPhysicalDeviceMemoryProperties(phys_device, &memory_props);
+
+        vkGetPhysicalDeviceFeatures(phys_device, &features);
+
+        uint32_t queue_count = 0;
+        vkGetPhysicalDeviceQueueFamilyProperties(phys_device, &queue_count, nullptr);
+        queue_props.resize(queue_count);
+        vkGetPhysicalDeviceQueueFamilyProperties(phys_device, &queue_count, queue_props.data());
+
+        if (inst.CheckExtensionEnabled(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
+            // VkPhysicalDeviceProperties2
+            props2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
+            setup_phys_device_props2_chain(props2, chain_for_phys_device_props2, inst, *this, show_promoted_structs);
+
+            vkGetPhysicalDeviceProperties2KHR(phys_device, &props2);
+            prepare_phys_device_props2_twocall_chain_vectors(chain_for_phys_device_props2);
+            vkGetPhysicalDeviceProperties2KHR(phys_device, &props2);
+
+            // VkPhysicalDeviceMemoryProperties2
+            memory_props2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR;
+            setup_phys_device_mem_props2_chain(memory_props2, chain_for_phys_device_mem_props2, *this);
+
+            vkGetPhysicalDeviceMemoryProperties2KHR(phys_device, &memory_props2);
+
+            // VkPhysicalDeviceFeatures2
+            features2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
+            setup_phys_device_features2_chain(features2, chain_for_phys_device_features2, *this, show_promoted_structs);
+
+            vkGetPhysicalDeviceFeatures2KHR(phys_device, &features2);
+
+            // std::vector<VkPhysicalDeviceQueueFamilyProperties2>
+            uint32_t queue_prop2_count = 0;
+            vkGetPhysicalDeviceQueueFamilyProperties2KHR(phys_device, &queue_prop2_count, nullptr);
+            queue_props2.resize(queue_prop2_count);
+            chain_for_queue_props2.resize(queue_prop2_count);
+            for (size_t i = 0; i < queue_props2.size(); i++) {
+                queue_props2[i].sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR;
+                setup_queue_properties2_chain(queue_props2[i], chain_for_queue_props2[i], *this);
+            }
+            vkGetPhysicalDeviceQueueFamilyProperties2KHR(phys_device, &queue_prop2_count, queue_props2.data());
+
+            if (CheckPhysicalDeviceExtensionIncluded(VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME) ||
+                api_version >= VK_API_VERSION_1_2) {
+                void *place = props2.pNext;
+                while (place) {
+                    VkBaseOutStructure *structure = static_cast<VkBaseOutStructure *>(place);
+                    if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES) {
+                        VkPhysicalDeviceDriverProperties *driver_driver_properties =
+                            reinterpret_cast<VkPhysicalDeviceDriverProperties *>(structure);
+                        driverID = driver_driver_properties->driverID;
+                        memcpy(driverName, driver_driver_properties->driverName, VK_MAX_DRIVER_NAME_SIZE);
+                        memcpy(driverInfo, driver_driver_properties->driverInfo, VK_MAX_DRIVER_INFO_SIZE);
+                        conformanceVersion = driver_driver_properties->conformanceVersion;
+                        found_driver_props = true;
+                    } else if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES) {
+                        VkPhysicalDeviceIDProperties *device_id_props = reinterpret_cast<VkPhysicalDeviceIDProperties *>(structure);
+                        memcpy(deviceUUID, device_id_props->deviceUUID, VK_UUID_SIZE);
+                        memcpy(driverUUID, device_id_props->driverUUID, VK_UUID_SIZE);
+                        memcpy(deviceLUID, device_id_props->deviceLUID, VK_LUID_SIZE);
+                        deviceNodeMask = device_id_props->deviceNodeMask;
+                        deviceLUIDValid = device_id_props->deviceLUIDValid;
+                        found_device_id_props = true;
+                    } else if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES) {
+                        VkPhysicalDeviceVulkan11Properties *vulkan_11_props =
+                            reinterpret_cast<VkPhysicalDeviceVulkan11Properties *>(structure);
+                        memcpy(deviceUUID, vulkan_11_props->deviceUUID, VK_UUID_SIZE);
+                        memcpy(driverUUID, vulkan_11_props->driverUUID, VK_UUID_SIZE);
+                        memcpy(deviceLUID, vulkan_11_props->deviceLUID, VK_LUID_SIZE);
+                        deviceNodeMask = vulkan_11_props->deviceNodeMask;
+                        deviceLUIDValid = vulkan_11_props->deviceLUIDValid;
+                        found_device_id_props = true;
+                    } else if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES) {
+                        VkPhysicalDeviceVulkan12Properties *vulkan_12_props =
+                            reinterpret_cast<VkPhysicalDeviceVulkan12Properties *>(structure);
+                        driverID = vulkan_12_props->driverID;
+                        memcpy(driverName, vulkan_12_props->driverName, VK_MAX_DRIVER_NAME_SIZE);
+                        memcpy(driverInfo, vulkan_12_props->driverInfo, VK_MAX_DRIVER_INFO_SIZE);
+                        conformanceVersion = vulkan_12_props->conformanceVersion;
+                        found_driver_props = true;
+                    }
+                    place = structure->pNext;
+                }
+            }
+        }
+
+        // Use the queue_props2 if they exist, else fallback on vulkan 1.0 queue_props
+        int queue_index = 0;
+        if (queue_props2.size() > 0) {
+            for (auto &queue_prop : queue_props2) {
+                extended_queue_props.push_back(
+                    AppQueueFamilyProperties(inst, phys_device, queue_prop.queueFamilyProperties, queue_index++, queue_prop.pNext));
+            }
+        } else {
+            for (auto &queue_prop : queue_props) {
+                extended_queue_props.push_back(AppQueueFamilyProperties(inst, phys_device, queue_prop, queue_index++, nullptr));
+            }
+        }
+
+        if (features.sparseBinding) {
+            enabled_features.sparseBinding = VK_TRUE;
+        }
+
+        std::vector<const char *> extensions_to_enable;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        for (const auto &extension : device_extensions) {
+            if (std::string(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME) == extension.extensionName) {
+                extensions_to_enable.push_back(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME);
+            }
+        }
+#endif
+
+        const float queue_priority = 1.0f;
+        // pick the first queue index and hope for the best
+        const VkDeviceQueueCreateInfo q_ci = {VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, nullptr, 0, 0, 1, &queue_priority};
+        VkDeviceCreateInfo device_ci{};
+        device_ci.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+        device_ci.queueCreateInfoCount = 1;
+        device_ci.pQueueCreateInfos = &q_ci;
+        device_ci.enabledExtensionCount = static_cast<uint32_t>(extensions_to_enable.size());
+        device_ci.ppEnabledExtensionNames = extensions_to_enable.data();
+        device_ci.pEnabledFeatures = &enabled_features;
+
+        VkResult err = vkCreateDevice(phys_device, &device_ci, nullptr, &dev);
+        if (err) THROW_VK_ERR("vkCreateDevice", err);
+
+        const std::array<VkImageTiling, 2> tilings = {VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_TILING_LINEAR};
+        const std::array<VkFormat, 8> formats = {
+            color_format,      VK_FORMAT_D16_UNORM,         VK_FORMAT_X8_D24_UNORM_PACK32, VK_FORMAT_D32_SFLOAT,
+            VK_FORMAT_S8_UINT, VK_FORMAT_D16_UNORM_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT,   VK_FORMAT_D32_SFLOAT_S8_UINT};
+
+        for (const VkImageTiling tiling : tilings) {
+            ImageTypeInfos image_type_infos;
+            image_type_infos.tiling = tiling;
+
+            for (const VkFormat format : formats) {
+                ImageTypeFormatInfo image_type_format_info;
+                image_type_format_info.format = format;
+
+                VkFormatProperties fmt_props;
+                vkGetPhysicalDeviceFormatProperties(phys_device, format, &fmt_props);
+                if ((tiling == VK_IMAGE_TILING_OPTIMAL && fmt_props.optimalTilingFeatures == 0) ||
+                    (tiling == VK_IMAGE_TILING_LINEAR && fmt_props.linearTilingFeatures == 0)) {
+                    continue;
+                }
+
+                VkImageCreateInfo image_ci_regular = GetImageCreateInfo(0, format, tiling, 0);
+                VkImageCreateInfo image_ci_transient =
+                    GetImageCreateInfo(0, format, tiling, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT);
+                VkImageCreateInfo image_ci_sparse =
+                    GetImageCreateInfo(VK_IMAGE_CREATE_SPARSE_BINDING_BIT, format, tiling, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
+
+                if (tiling == VK_IMAGE_TILING_LINEAR) {
+                    if (format == color_format) {
+                        image_ci_regular.usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+                        image_ci_transient.usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+                    } else {
+                        // linear tiling is only applicable to color image types
+                        continue;
+                    }
+                } else {
+                    if (format == color_format) {
+                        image_ci_regular.usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+                        image_ci_transient.usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+
+                    } else {
+                        image_ci_regular.usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+                        image_ci_transient.usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+                    }
+                }
+
+                auto image_ts_regular_ret =
+                    FillImageTypeSupport(inst, phys_device, dev, ImageTypeSupport::Type::regular, image_ci_regular);
+                if (image_ts_regular_ret) {
+                    image_type_format_info.type_support.push_back(image_ts_regular_ret.value());
+                }
+                auto image_ts_transient_ret =
+                    FillImageTypeSupport(inst, phys_device, dev, ImageTypeSupport::Type::transient, image_ci_transient);
+                if (image_ts_transient_ret) {
+                    image_type_format_info.type_support.push_back(image_ts_transient_ret.value());
+                }
+
+                if (enabled_features.sparseBinding) {
+                    auto image_ts_sparse_ret =
+                        FillImageTypeSupport(inst, phys_device, dev, ImageTypeSupport::Type::sparse, image_ci_sparse);
+                    if (image_ts_sparse_ret) {
+                        image_type_format_info.type_support.push_back(image_ts_sparse_ret.value());
+                    }
+                }
+                image_type_infos.formats.push_back(image_type_format_info);
+            }
+            memory_image_support_types.push_back(image_type_infos);
+        }
+
+        // Memory //
+
+        struct VkBaseOutStructure *structure = NULL;
+        if (inst.CheckExtensionEnabled(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
+            structure = (struct VkBaseOutStructure *)memory_props2.pNext;
+
+            while (structure) {
+                if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT &&
+                    CheckPhysicalDeviceExtensionIncluded(VK_EXT_MEMORY_BUDGET_EXTENSION_NAME)) {
+                    VkPhysicalDeviceMemoryBudgetPropertiesEXT *mem_budget_props =
+                        reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT *>(structure);
+                    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; i++) {
+                        heapBudget[i] = mem_budget_props->heapBudget[i];
+                        heapUsage[i] = mem_budget_props->heapUsage[i];
+                    }
+                }
+
+                structure = structure->pNext;
+            }
+        }
+        // TODO buffer - memory type compatibility
+
+        // Video //
+        video_profiles = enumerate_supported_video_profiles(*this);
+
+        // Display //
+        display_planes = enumerate_display_planes(*this);
+        displays = enumerate_displays(*this, display_planes);
+
+        vkDestroyDevice(dev, nullptr);
+        dev = VK_NULL_HANDLE;
+    }
+    ~AppGpu() { vkDestroyDevice(dev, nullptr); }
+
+    AppGpu(const AppGpu &) = delete;
+    const AppGpu &operator=(const AppGpu &) = delete;
+
+    bool CheckPhysicalDeviceExtensionIncluded(std::string extension_to_check) const {
+        return std::any_of(
+            device_extensions.begin(), device_extensions.end(),
+            [extension_to_check](const VkExtensionProperties &prop) { return prop.extensionName == extension_to_check; });
+    }
+
+    // Helper function to determine whether a format range is currently supported.
+    bool FormatRangeSupported(const FormatRange &format_range) const {
+        // Formats from base vulkan spec
+        if (format_range.minimum_instance_version == 0 && format_range.extension_name == nullptr) {
+            return true;
+        }
+
+        // True if this extension is present
+        if (format_range.extension_name != nullptr) {
+            return CheckPhysicalDeviceExtensionIncluded(format_range.extension_name);
+        }
+
+        // True if standard and supported by both this instance and this GPU
+        if (inst.api_version >= format_range.minimum_instance_version &&
+            APIVersion(props.apiVersion) >= format_range.minimum_instance_version) {
+            return true;
+        }
+
+        // Otherwise, not supported.
+        return false;
+    }
+
+    VkPhysicalDeviceProperties GetDeviceProperties() {
+        if (inst.CheckExtensionEnabled(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
+            return props2.properties;
+        } else {
+            return props;
+        }
+    }
+
+    // Vendor specific driverVersion mapping scheme
+    // If one isn't present, fall back to the standard Vulkan scheme
+    std::string GetDriverVersionString() {
+        uint32_t v = props.driverVersion;
+        if ((found_driver_props && driverID == VK_DRIVER_ID_NVIDIA_PROPRIETARY) ||
+            (!found_driver_props && props.deviceID == 4318)) {
+            return std::to_string((v >> 22) & 0x3ff) + "." + std::to_string((v >> 14) & 0x0ff) + "." +
+                   std::to_string((v >> 6) & 0x0ff) + "." + std::to_string(v & 0x003f);
+        } else if ((found_driver_props && driverID == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS)
+#if defined(WIN32)
+                   || (!found_driver_props && props.deviceID == 0x8086)  // only do the fallback check if running in windows
+#endif
+        ) {
+            return std::to_string(v >> 14) + "." + std::to_string(v & 0x3fff);
+        } else {
+            // AMD uses the standard vulkan scheme
+            return APIVersion(v).str();
+        }
+    }
+    const AppDisplay *FindDisplay(VkDisplayKHR handle) {
+        for (const auto &disp : displays) {
+            if (disp.properties.display == handle) {
+                return &disp;
+            }
+        }
+        return NULL;
+    }
+};
+
+std::vector<VkPhysicalDeviceToolPropertiesEXT> GetToolingInfo(AppGpu &gpu) {
+    if (vkGetPhysicalDeviceToolPropertiesEXT == nullptr) return {};
+    return GetVector<VkPhysicalDeviceToolPropertiesEXT>("vkGetPhysicalDeviceToolPropertiesEXT",
+                                                        vkGetPhysicalDeviceToolPropertiesEXT, gpu.phys_device);
+}
+
+std::vector<VkCooperativeMatrixPropertiesKHR> GetCooperativeMatrixInfo(AppGpu &gpu) {
+    if (vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR == nullptr) return {};
+    return GetVector<VkCooperativeMatrixPropertiesKHR>("vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR",
+                                                       vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, gpu.phys_device);
+}
+std::vector<VkTimeDomainKHR> GetTimeDomainInfo(AppGpu &gpu) {
+    if (vkGetPhysicalDeviceCalibrateableTimeDomainsKHR == nullptr) return {};
+    return GetVector<VkTimeDomainKHR>("vkGetPhysicalDeviceCalibrateableTimeDomainsKHR",
+                                      vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, gpu.phys_device);
+}
+std::vector<VkPhysicalDeviceFragmentShadingRateKHR> GetFragmentShadingRateInfo(AppGpu &gpu) {
+    if (vkGetPhysicalDeviceFragmentShadingRatesKHR == nullptr) return {};
+    return GetVector<VkPhysicalDeviceFragmentShadingRateKHR>("vkGetPhysicalDeviceFragmentShadingRatesKHR",
+                                                             vkGetPhysicalDeviceFragmentShadingRatesKHR, gpu.phys_device);
+}
+// Returns vector where each index maps to VkSampleCountFlagBits
+std::vector<VkMultisamplePropertiesEXT> GetSampleLocationInfo(AppGpu &gpu) {
+    if (vkGetPhysicalDeviceMultisamplePropertiesEXT == nullptr) return {};
+    std::vector<VkMultisamplePropertiesEXT> result;
+    // 7 covers VK_SAMPLE_COUNT_1_BIT to 64_BIT
+    for (uint32_t i = 0; i < 7; i++) {
+        const VkSampleCountFlagBits sample_count = (VkSampleCountFlagBits)(1 << i);
+        VkMultisamplePropertiesEXT props = {VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT, nullptr};
+        vkGetPhysicalDeviceMultisamplePropertiesEXT(gpu.phys_device, sample_count, &props);
+        result.emplace_back(props);
+    }
+    return result;
+}
+
+// --------- Format Properties ----------//
+// can't use autogen because that is put in a header that we can't include because that header depends on stuff defined here
+bool operator==(const VkFormatProperties &a, const VkFormatProperties b) {
+    return a.linearTilingFeatures == b.linearTilingFeatures && a.optimalTilingFeatures == b.optimalTilingFeatures &&
+           a.bufferFeatures == b.bufferFeatures;
+}
+bool operator==(const VkFormatProperties3 &a, const VkFormatProperties3 b) {
+    return a.linearTilingFeatures == b.linearTilingFeatures && a.optimalTilingFeatures == b.optimalTilingFeatures &&
+           a.bufferFeatures == b.bufferFeatures;
+}
+
+struct PropFlags {
+    VkFormatProperties props;
+    VkFormatProperties3 props3;
+
+    bool operator==(const PropFlags &other) const { return props == other.props && props3 == other.props3; }
+};
+
+PropFlags get_format_properties(const AppGpu &gpu, VkFormat fmt) {
+    VkFormatProperties props;
+    vkGetPhysicalDeviceFormatProperties(gpu.phys_device, fmt, &props);
+
+    VkFormatProperties3 props3{};
+    props3.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3;
+
+    if (gpu.inst.CheckExtensionEnabled(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME) &&
+        gpu.CheckPhysicalDeviceExtensionIncluded(VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME)) {
+        VkFormatProperties2 props2{};
+        props2.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2;
+        props2.formatProperties = props;
+        props2.pNext = static_cast<void *>(&props3);
+        vkGetPhysicalDeviceFormatProperties2KHR(gpu.phys_device, fmt, &props2);
+    }
+    return {props, props3};
+}
+
+namespace std {
+template <>
+struct hash<VkFormatProperties> {
+    std::size_t operator()(const VkFormatProperties &k) const {
+        return ((std::hash<uint32_t>()(k.linearTilingFeatures) ^ (std::hash<uint32_t>()(k.optimalTilingFeatures) << 1)) >> 1) ^
+               (std::hash<uint32_t>()(k.bufferFeatures) << 1);
+    }
+};
+template <>
+struct hash<VkFormatProperties3> {
+    std::size_t operator()(const VkFormatProperties3 &k) const {
+        return ((std::hash<uint64_t>()(k.linearTilingFeatures) ^ (std::hash<uint64_t>()(k.optimalTilingFeatures) << 1)) >> 1) ^
+               (std::hash<uint64_t>()(k.bufferFeatures) << 1);
+    }
+};
+template <>
+struct hash<PropFlags> {
+    std::size_t operator()(const PropFlags &k) const {
+        return (std::hash<VkFormatProperties>()(k.props) ^ std::hash<VkFormatProperties3>()(k.props3)) >> 1;
+    }
+};
+}  // namespace std
diff --git a/tools/Vulkan-Tools/vulkaninfo/vulkaninfo.md b/tools/Vulkan-Tools/vulkaninfo/vulkaninfo.md
new file mode 100644
index 00000000..17b4a8b6
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/vulkaninfo.md
@@ -0,0 +1,116 @@
+<!-- markdownlint-disable MD041 -->
+<!-- Copyright 2015-2023 LunarG, Inc. -->
+
+[![Khronos Vulkan][1]][2]
+
+[1]: https://vulkan.lunarg.com/img/Vulkan_100px_Dec16.png "https://www.khronos.org/vulkan/"
+[2]: https://www.khronos.org/vulkan/
+
+[![Creative Commons][3]][4]
+
+[3]: https://i.creativecommons.org/l/by-nd/4.0/88x31.png "Creative Commons License"
+[4]: https://creativecommons.org/licenses/by-nd/4.0/
+
+# Vulkan Information
+
+Vulkan Info is a program provided in the SDK which outputs various types of Vulkan information such as:
+
+- device properties of identified GPUs
+- Vulkan extensions supported by each GPU
+- recognized layers
+- supported image formats and format properties.
+
+## Running Vulkan Info
+
+After downloading and installing the SDK and setting up the runtime environment (see the [Getting Started](./getting_started.md#user-content-download-the-sdk) documentation) you will be able to run the Vulkan Info program from a command prompt.
+
+```
+vulkaninfo
+```
+
+Executing `vulkaninfo` without specifying the type of output will default to human-readable output to the console.
+
+Note: The Vulkan Info binary found in the Windows Vulkan SDK is named `vulkaninfoSDK.exe`. This is so it doesn't get confused with the Vulkan Info distributed by an IVH, as it is installed with the Vulkan Runtime Package. Since the SDK does not install Vulkan Info to the path, the Windows command line version used will be from the IHV distribution. To run the SDK version, either use the start menu shortcuts or navigate to the `VulkanSDK/Bin` directory and run `vulkaninfoSDK.exe` directly.
+
+```
+vulkaninfo --html
+```
+
+To organize output in a convenient HTML format use the `--html` option. Executing `vulkaninfo` with the `--html` option produces a file called `vulkaninfo.html` and can be found in your build directory.
+
+```
+vulkaninfo --json
+```
+Produce a json version of vulkaninfo output conforming to the [Vulkan Profiles schema](https://schema.khronos.org/vulkan/), saved as \"VP_VULKANINFO_[DEVICE_NAME]_[DRIVER_VERSION].json\", of the first gpu in the system.
+
+JSON output can be specified with the `-j` option and for multi-GPU systems, a single GPU can be targeted using the `--json=`*`GPU-number`* option where the *`GPU-number`* indicates the GPU of interest (e.g., `--json=0`). To determine the GPU number corresponding to a particular GPU, execute `vulkaninfo --summary` option (or none at all) first; doing so will summarize all GPUs in the system.
+
+Use the `--help` or `-h` option to produce a list of all available Vulkan Info options.
+
+```
+vulkaninfo - Summarize Vulkan information in relation to the current environment.
+
+USAGE:
+    vulkaninfo --summary
+    vulkaninfo -o <filename> | --output <filename>
+    vulkaninfo -j | -j=<gpu-number> | --json | --json=<gpu-number>
+    vulkaninfo --text
+    vulkaninfo --html
+    vulkaninfo --show-all
+    vulkaninfo --show-formats
+
+OPTIONS:
+[-h, --help]        Print this help.
+[--summary]         Show a summary of the instance and GPU's on a system.
+[-o <filename>, --output <filename>]
+                    Print output to a new file whose name is specified by filename.
+                    File will be written to the current working directory.
+[--text]            Produce a text version of vulkaninfo output to stdout. This is
+                    the default output.
+[--html]            Produce an html version of vulkaninfo output, saved as
+                    \"vulkaninfo.html\" in the directory in which the command
+                    is run.
+[-j, --json]        Produce a json version of vulkaninfo output conforming to the Vulkan
+                    Profiles schema, saved as
+                    \"VP_VULKANINFO_[DEVICE_NAME]_[DRIVER_VERSION].json\"
+                    of the first gpu in the system.
+[-j=<gpu-number>, --json=<gpu-number>]
+                    For a multi-gpu system, a single gpu can be targeted by
+                    specifying the gpu-number associated with the gpu of
+                    interest. This number can be determined by running
+                    vulkaninfo without any options specified.
+[--show-all]        Show everything (includes all the below options)
+[--show-formats]    Display the format properties of each physical device.
+                    Note: This only affects text output.
+[--show-tool-props] Show the active VkPhysicalDeviceToolPropertiesEXT that vulkaninfo finds.
+[--show-promoted-structs]
+                    Include structs promoted to core in pNext Chains.
+[--show-video-props]
+                    Display the video profile info, video capabilities and
+                    video format properties of each video profile supported
+                    by each physical device.
+                    Note: This only affects text output which by default
+                    only contains the list of supported video profile names.
+```
+
+### Windows
+
+Vulkan Info can also be found as a shortcut under the Start Menu.
+
+- `Start Menu -> Vulkan SDK`*`version`*`-> vulkaninfo`
+
+Note: In order to review and/or save the output produced when using Visual Studio execute `vulkaninfo` with the JSON option, you will have to redirect output to a file by modifying the command line arguments in the debug options.
+
+Note: The Vulkan Info binary found in the Vulkan SDK is renamed to `vulkaninfoSDK.exe`. This was done to demark any Vulkan Info version installed by the Vulkan Runtime Package, which is from an IHV distribution. When using command line on Windows, the Vulkan info version used will be from the IHV distribution, not the SDK. To run the SDK version, either use the start menu shortcuts or navigate to the `VulkanSDK/Bin` directory and run `vulkaninfoSDK.exe` directly.
+
+### iOS Devices
+
+Vulkan Info is now avaialble for iOS devices, but must be built manually.
+
+The Vulkan Info project contains a folder at [vulkaninfo/ios](https://github.com/KhronosGroup/Vulkan-Tools/tree/main/vulkaninfo/iOS) that contains an XCode project that will build Vulkan Info for iOS devices. In order to deploy to an iOS device, the developer must be a member of the [Apple Developer Program](https://developer.apple.com/programs/). In addition, Vulkan Info makes use of the [MoltenVK](https://github.com/KhronosGroup/MoltenVK) libraries, which is a seperate project from Vulkan-Tools and you will need to add the MoltenVK libraries to your XCode project manually. See the [LunarG Getting Started with the macOS SDK](https://vulkan.lunarg.com/doc/sdk/latest/mac/getting_started.html) guide for more information about using MoltenVK in the Vulkan SDK.
+
+When Vulkan Info is run on an iOS device, it will create the standard vulkaninfo.json file and also a portability.json file. An HTML file is also created, and is displayed in a webview on the iOS device when the application is run. These files are located on the iOS device, and are available via the [iOS application file sharing mechanism](https://support.apple.com/en-us/HT201301) via iTunes for Windows or macOS. You can also access these files using the macOS Finder or Windows Explorer when the device is attached to the host computer via a USB cable. Select the device, and navigate to the "vulkaninfo" folder to access these files. There is currently no supported means to access these files on an iOS device from a Linux host computer.
+
+
+
+
diff --git a/tools/Vulkan-Tools/vulkaninfo/vulkaninfo.rc.in b/tools/Vulkan-Tools/vulkaninfo/vulkaninfo.rc.in
new file mode 100644
index 00000000..dd5562f5
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/vulkaninfo.rc.in
@@ -0,0 +1,58 @@
+//
+// Copyright (c) 2018-2023 The Khronos Group Inc.
+// Copyright (c) 2018-2023 Valve Corporation
+// Copyright (c) 2018-2023 LunarG, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Author: Lenny Komow <david@lunarg.com>
+// Author: Charles Giessen <charles@lunarg.com>
+
+#include "winres.h"
+
+// All set through CMake
+#define VER_FILE_VERSION ${VULKANINFO_VER_FILE_VERSION}
+#define VER_FILE_VERSION_STR ${VULKANINFO_VER_FILE_VERSION_STR}
+#define VER_FILE_DESCRIPTION_STR ${VULKANINFO_VER_FILE_DESCRIPTION_STR}
+#define VER_COPYRIGHT_STR "Copyright (C) 2015-${VULKANINFO_CUR_COPYRIGHT_STR}"
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION VER_FILE_VERSION
+ PRODUCTVERSION VER_FILE_VERSION
+ FILEFLAGSMASK 0x3fL
+#ifdef _DEBUG
+ FILEFLAGS VS_FF_DEBUG
+#else
+ FILEFLAGS 0x0L
+#endif
+
+ FILEOS 0x00000L
+ FILETYPE VFT_DLL
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "04090000"
+        BEGIN
+            VALUE "FileDescription", VER_FILE_DESCRIPTION_STR
+            VALUE "FileVersion", VER_FILE_VERSION_STR
+            VALUE "LegalCopyright", VER_COPYRIGHT_STR
+            VALUE "ProductName", "Vulkaninfo"
+            VALUE "ProductVersion", VER_FILE_VERSION_STR
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 0000
+    END
+END
diff --git a/tools/Vulkan-Tools/vulkaninfo/vulkaninfo_functions.h b/tools/Vulkan-Tools/vulkaninfo/vulkaninfo_functions.h
new file mode 100644
index 00000000..2876155c
--- /dev/null
+++ b/tools/Vulkan-Tools/vulkaninfo/vulkaninfo_functions.h
@@ -0,0 +1,268 @@
+/*
+ * Copyright (c) 2025-2026 The Khronos Group Inc.
+ * Copyright (c) 2025-2026 Valve Corporation
+ * Copyright (c) 2025-2026 LunarG, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Charles Giessen <charles@lunarg.com>
+ *
+ */
+#pragma once
+
+// Need to include relevant system headers to open the dynamic library
+#if defined(WIN32)
+#include <windows.h>
+#elif defined(__APPLE__)
+#include <stdlib.h>
+#include <dlfcn.h>
+#else
+#include <dlfcn.h>
+#endif
+
+// We are providing storage for all functions, make sure the vulkan headers doesn't conflate with ours.
+#if !defined(VK_NO_PROTOTYPES)
+#define VK_NO_PROTOTYPES
+#endif
+
+#include <vulkan/vulkan.h>
+
+void* vulkan_library;
+
+// Global Functions
+PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
+PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties;
+PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties;
+PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion;
+PFN_vkCreateInstance vkCreateInstance;
+
+// Per-platform Instance functions
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR;
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR;
+#endif
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR;
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR;
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR;
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT;
+#endif
+#if defined(VK_USE_PLATFORM_MACOS_MVK)
+PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK;
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX;
+#endif
+#if defined(VK_USE_PLATFORM_DISPLAY)
+PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR;
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT;
+#endif
+#if defined(VK_USE_PLATFORM_GGP)
+PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP;
+#endif
+// Instance functions
+PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT;
+PFN_vkCreateDevice vkCreateDevice;
+PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT;
+PFN_vkDestroyInstance vkDestroyInstance;
+PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR;
+PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties;
+PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR;
+PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR;
+PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR;
+PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR;
+PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR;
+PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures;
+PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties;
+PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
+PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties;
+PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties;
+PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
+PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR;
+PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR;
+PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR;
+PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR;
+PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR;
+PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR;
+PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR vkGetPhysicalDeviceVideoFormatPropertiesKHR;
+PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR;
+PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR;
+PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties;
+PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR;
+PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR;
+PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR;
+PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR;
+PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices;
+PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT;
+PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT;
+PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR;
+PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR;
+PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR vkGetPhysicalDeviceCalibrateableTimeDomainsKHR;
+PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR;
+PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT;
+
+// Device functions
+PFN_vkCreateImage vkCreateImage;
+PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
+PFN_vkDestroyImage vkDestroyImage;
+PFN_vkDestroyDevice vkDestroyDevice;
+
+#define LOAD_INSTANCE_FUNCTION(instance, function) function = (PFN_##function)vkGetInstanceProcAddr(instance, #function)
+
+static VkResult load_vulkan_library() {
+    vulkan_library = NULL;
+#if defined(WIN32)
+    HMODULE library = LoadLibraryA("vulkan-1.dll");
+    if (library == NULL) return VK_ERROR_INITIALIZATION_FAILED;
+
+    vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)(void (*)(void))GetProcAddress(library, "vkGetInstanceProcAddr");
+#elif defined(__APPLE__)
+    void* library = dlopen("libvulkan.dylib", RTLD_NOW | RTLD_LOCAL);
+    if (library == NULL) {
+        library = dlopen("libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL);
+    }
+    if (library == NULL && getenv("DYLD_FALLBACK_LIBRARY_PATH") == NULL) {
+        library = dlopen("/usr/local/lib/libvulkan.dylib", RTLD_NOW | RTLD_LOCAL);
+        if (library == NULL) {
+            library = dlopen("/usr/local/lib/libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL);
+        }
+    }
+    if (library == NULL) {
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+
+    vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)dlsym(library, "vkGetInstanceProcAddr");
+#else  // Assume everything else supports dlopen
+    void* library = dlopen("libvulkan.so.1", RTLD_NOW | RTLD_LOCAL);
+    if (library == NULL) library = dlopen("libvulkan.so", RTLD_NOW | RTLD_LOCAL);
+    if (library == NULL) {
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+    vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)dlsym(library, "vkGetInstanceProcAddr");
+#endif
+    if (vkGetInstanceProcAddr == NULL) {
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+    vulkan_library = library;
+    LOAD_INSTANCE_FUNCTION(NULL, vkEnumerateInstanceExtensionProperties);
+    LOAD_INSTANCE_FUNCTION(NULL, vkEnumerateInstanceLayerProperties);
+    LOAD_INSTANCE_FUNCTION(NULL, vkEnumerateInstanceVersion);
+    LOAD_INSTANCE_FUNCTION(NULL, vkCreateInstance);
+
+    return VK_SUCCESS;
+}
+
+static void unload_vulkan_library() {
+    if (vulkan_library != NULL) {
+#if defined(WIN32)
+        FreeLibrary((HMODULE)vulkan_library);
+#else
+        dlclose(vulkan_library);
+#endif
+        vulkan_library = NULL;
+    }
+}
+
+static void load_vulkan_instance_functions(VkInstance instance) {
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateWin32SurfaceKHR);
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateWaylandSurfaceKHR);
+#endif
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateAndroidSurfaceKHR);
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateXlibSurfaceKHR);
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateXcbSurfaceKHR);
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateMetalSurfaceEXT);
+#endif
+#if defined(VK_USE_PLATFORM_MACOS_MVK)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateMacOSSurfaceMVK);
+#endif
+#if defined(VK_USE_PLATFORM_SCREEN_QNX)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateScreenSurfaceQNX);
+#endif
+#if defined(VK_USE_PLATFORM_DISPLAY)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateDisplayPlaneSurfaceKHR);
+#endif
+#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateDirectFBSurfaceEXT);
+#endif
+#if defined(VK_USE_PLATFORM_GGP)
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateStreamDescriptorSurfaceGGP);
+#endif
+
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateDebugReportCallbackEXT);
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateDevice);
+    LOAD_INSTANCE_FUNCTION(instance, vkDestroyDebugReportCallbackEXT);
+    LOAD_INSTANCE_FUNCTION(instance, vkDestroyInstance);
+    LOAD_INSTANCE_FUNCTION(instance, vkDestroySurfaceKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkEnumerateDeviceExtensionProperties);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetDisplayModePropertiesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetDisplayPlaneCapabilitiesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetDisplayPlaneSupportedDisplaysKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceDisplayPlanePropertiesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceDisplayPropertiesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceFeatures);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceFormatProperties);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceMemoryProperties);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceProperties);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceQueueFamilyProperties);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfaceCapabilitiesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfaceFormatsKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfacePresentModesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfaceSupportKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceVideoCapabilitiesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfaceFormats2KHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfaceCapabilities2KHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceVideoFormatPropertiesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkEnumeratePhysicalDeviceGroupsKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetDeviceGroupPresentCapabilitiesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceImageFormatProperties);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceProperties2KHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceMemoryProperties2KHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceFeatures2KHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceQueueFamilyProperties2KHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkEnumeratePhysicalDevices);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceSurfaceCapabilities2EXT);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceToolPropertiesEXT);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceFormatProperties2KHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceCalibrateableTimeDomainsKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceFragmentShadingRatesKHR);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetPhysicalDeviceMultisamplePropertiesEXT);
+
+    // Load device functions using vkGetInstanceProcAddr, vulkaninfo doesn't care about the extra indirection it causes
+    LOAD_INSTANCE_FUNCTION(instance, vkCreateImage);
+    LOAD_INSTANCE_FUNCTION(instance, vkGetImageMemoryRequirements);
+    LOAD_INSTANCE_FUNCTION(instance, vkDestroyImage);
+    LOAD_INSTANCE_FUNCTION(instance, vkDestroyDevice);
+}
+
+#undef LOAD_INSTANCE_FUNCTION