Merge tag 'vulkan-sdk-1.3.268.0'

Bug:b/319117470

Change-Id: Ifa16007c332ff937bb3fca9a72b073d8e647386f
diff --git a/.appveyor.yml b/.appveyor.yml
deleted file mode 100644
index b08c47b..0000000
--- a/.appveyor.yml
+++ /dev/null
@@ -1,108 +0,0 @@
-# Windows Build Configuration for AppVeyor
-# http://www.appveyor.com/docs/appveyor-yml
-
-# build version format
-version: "{build}"
-
-os: Visual Studio 2015
-
-platform:
-  - x64
-
-configuration:
-  - Debug
-  - Release
-
-branches:
-  only:
-    - master
-
-# changes to these files don't need to trigger testing
-skip_commits:
-  files:
-    - README.md
-    - README-spirv-remap.txt
-    - LICENSE.txt
-    - CODE_OF_CONDUCT.md
-    - BUILD.*
-    - WORKSPACE
-    - kokoro/*
-    - make-revision
-    - Android.mk
-    - _config.yml
-
-# Travis advances the master-tot tag to current top of the tree after
-# each push into the master branch, because it relies on that tag to
-# upload build artifacts to the master-tot release. This will cause
-# double testing for each push on Appveyor: one for the push, one for
-# the tag advance. Disable testing tags.
-skip_tags: true
-
-clone_depth: 5
-
-matrix:
-  fast_finish: true # Show final status immediately if a test fails.
-
-# scripts that run after cloning repository
-install:
-  - C:/Python27/python.exe update_glslang_sources.py
-  - set PATH=C:\ninja;C:\Python36;%PATH%
-  - git clone https://github.com/google/googletest.git External/googletest
-
-build:
-  parallel: true  # enable MSBuild parallel builds
-  verbosity: minimal
-
-build_script:
-  - mkdir build && cd build
-  - cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_INSTALL_PREFIX=install ..
-  - cmake --build . --config %CONFIGURATION% --target install
-
-test_script:
-  - ctest -C %CONFIGURATION% --output-on-failure
-  - cd ../Test && bash runtests
-  - cd ../build
-
-after_test:
-  # For debug build, the generated dll has a postfix "d" in its name.
-  - ps: >-
-      If ($env:configuration -Match "Debug") {
-        $env:SUFFIX="d"
-      } Else {
-        $env:SUFFIX=""
-      }
-  - cd install
-  # Zip all glslang artifacts for uploading and deploying
-  - 7z a glslang-master-windows-"%PLATFORM%"-"%CONFIGURATION%".zip
-    bin\glslangValidator.exe
-    bin\spirv-remap.exe
-    include\glslang\*
-    lib\GenericCodeGen%SUFFIX%.lib
-    lib\glslang%SUFFIX%.lib
-    lib\glslang-default-resource-limits%SUFFIX%.lib
-    lib\HLSL%SUFFIX%.lib
-    lib\MachineIndependent%SUFFIX%.lib
-    lib\OGLCompiler%SUFFIX%.lib
-    lib\OSDependent%SUFFIX%.lib
-    lib\SPIRV%SUFFIX%.lib
-    lib\SPVRemapper%SUFFIX%.lib
-    lib\SPIRV-Tools%SUFFIX%.lib
-    lib\SPIRV-Tools-opt%SUFFIX%.lib
-
-artifacts:
-  - path: build\install\*.zip
-    name: artifacts-zip
-
-deploy:
-  - provider: GitHub
-    auth_token:
-      secure: YglcSYdl0TylEa59H4K6lylBEDr586NAt2EMgZquSo+iuPrwgZQuJLPCoihSm9y6
-    release: master-tot
-    description: "Continuous build of the latest master branch by Appveyor and Github"
-    artifact: artifacts-zip
-    draft: false
-    prerelease: false
-    force_update: true
-    on:
-      branch: master
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000..2190055
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,22 @@
+# Copyright 2023 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+version: 2
+updates:
+  - package-ecosystem: "github-actions" # Necessary to update action hashes	
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    # Allow up to 3 opened pull requests for github-actions versions
+    open-pull-requests-limit: 3
diff --git a/.github/workflows/continuous_deployment.yml b/.github/workflows/continuous_deployment.yml
index c375ac4..68cad7a 100644
--- a/.github/workflows/continuous_deployment.yml
+++ b/.github/workflows/continuous_deployment.yml
@@ -20,11 +20,26 @@
     workflow_dispatch:
     push:
         branches:
-            - master
+            - main
+        paths-ignore:
+            - 'README.md'
+            - 'README-spirv-remap.txt'
+            - 'LICENSE.txt'
+            - 'CODE_OF_CONDUCT.md'
+            - 'BUILD.*'
+            - 'WORKSPACE'
+            - 'kokoro/*'
+            - 'make-revision'
+            - 'Android.mk'
+            - '_config.yml'
+
+permissions: read-all
 
 jobs:
     linux:
         runs-on: ${{matrix.os.genus}}
+        permissions:
+            contents: write
         strategy:
             fail-fast: false
             matrix:
@@ -32,8 +47,9 @@
                 compiler: [{cc: clang, cxx: clang++}, {cc: gcc, cxx: g++}]
                 cmake_build_type: [Debug, Release]
         steps:
-            - uses: actions/checkout@v2
-            - uses: actions/setup-python@v2
+            - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 # v4.1.0
+            - uses: lukka/get-cmake@8be6cca406b575906541e8e3b885d46f416bba39 # v3.27.7
+            - uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
               with:
                   python-version: '3.7'
             - name: Install Ubuntu Package Dependencies
@@ -71,10 +87,11 @@
             - name: Zip
               if: ${{ matrix.compiler.cc == 'clang' }}
               env:
-                  ARCHIVE: glslang-master-${{matrix.os.family}}-${{matrix.cmake_build_type}}.zip
+                  ARCHIVE: glslang-main-${{matrix.os.family}}-${{matrix.cmake_build_type}}.zip
               run: |
                   cd build/install
                   zip ${ARCHIVE} \
+                      bin/glslang \
                       bin/glslangValidator \
                       include/glslang/* \
                       include/glslang/**/* \
@@ -92,8 +109,8 @@
             - name: Deploy
               if: ${{ matrix.compiler.cc == 'clang' }}
               env:
-                  ARCHIVE: glslang-master-${{matrix.os.family}}-${{matrix.cmake_build_type}}.zip
-              uses: actions/github-script@v5
+                  ARCHIVE: glslang-main-${{matrix.os.family}}-${{matrix.cmake_build_type}}.zip
+              uses: actions/github-script@d7906e4ad0b1822421a7e6a35d5ca353c962f410 # v6.4.1
               with:
                   script: |
                       const script = require('.github/workflows/deploy.js')
@@ -101,6 +118,8 @@
 
     macos:
         runs-on: ${{matrix.os.genus}}
+        permissions:
+            contents: write
         strategy:
             fail-fast: false
             matrix:
@@ -108,8 +127,9 @@
                 compiler: [{cc: clang, cxx: clang++}]
                 cmake_build_type: [Debug, Release]
         steps:
-            - uses: actions/checkout@v2
-            - uses: actions/setup-python@v2
+            - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 # v4.1.0
+            - uses: lukka/get-cmake@8be6cca406b575906541e8e3b885d46f416bba39 # v3.27.7
+            - uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
               with:
                   python-version: '3.7'
             - name: Install GoogleTest
@@ -142,10 +162,11 @@
                   cd ../Test && ./runtests
             - name: Zip
               env:
-                  ARCHIVE: glslang-master-${{matrix.os.family}}-${{matrix.cmake_build_type}}.zip
+                  ARCHIVE: glslang-main-${{matrix.os.family}}-${{matrix.cmake_build_type}}.zip
               run: |
                   cd build/install
                   zip ${ARCHIVE} \
+                      bin/glslang \
                       bin/glslangValidator \
                       include/glslang/* \
                       include/glslang/**/* \
@@ -162,8 +183,100 @@
                       lib/libSPIRV-Tools-opt.a
             - name: Deploy
               env:
+                  ARCHIVE: glslang-main-${{matrix.os.family}}-${{matrix.cmake_build_type}}.zip
+              uses: actions/github-script@d7906e4ad0b1822421a7e6a35d5ca353c962f410 # v6.4.1
+              with:
+                  script: |
+                      const script = require('.github/workflows/deploy.js')
+                      await script({github, context, core})
+
+    windows:
+        runs-on: ${{matrix.os.genus}}
+        permissions:
+            contents: write
+        strategy:
+            fail-fast: false
+            matrix:
+                os: [{genus: windows-2019, family: windows}]
+                cmake_build_type: [Debug, Release]
+        steps:
+            - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 # v4.1.0
+            - uses: lukka/get-cmake@8be6cca406b575906541e8e3b885d46f416bba39 # v3.27.7
+            - uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
+              with:
+                  python-version: '3.7'
+            - name: Install GoogleTest
+              run: |
+                  # check out pre-breakage version of googletest; can be deleted when
+                  # issue 3128 is fixed
+                  # git clone --depth=1 https://github.com/google/googletest.git External/googletest
+                  mkdir -p External/googletest
+                  cd External/googletest
+                  git init
+                  git remote add origin https://github.com/google/googletest.git
+                  git fetch --depth 1 origin 0c400f67fcf305869c5fb113dd296eca266c9725
+                  git reset --hard FETCH_HEAD
+                  cd ../..
+            - name: Update Glslang Sources
+              run: |
+                  python update_glslang_sources.py
+            - name: Build
+              run: |
+                  cmake -S. -Bbuild -G "Visual Studio 16 2019" -A x64 -DCMAKE_INSTALL_PREFIX="$PWD/build/install"
+                  cmake --build build --config ${{matrix.cmake_build_type}} --target install
+            - name: Test
+              run: |
+                  cd build
+                  ctest -C ${{matrix.cmake_build_type}} --output-on-failure
+                  cd ../Test && bash runtests
+            - name: Zip
+              if: ${{ matrix.cmake_build_type == 'Debug' }}
+              env:
+                  ARCHIVE: glslang-master-${{matrix.os.family}}-Debug.zip
+              run: |
+                  cd build/install
+                  7z a ${{env.ARCHIVE}} `
+                      bin/glslang.exe `
+                      bin/glslangValidator.exe `
+                      bin/spirv-remap.exe `
+                      include/glslang/* `
+                      lib/GenericCodeGend.lib `
+                      lib/glslangd.lib `
+                      lib/glslang-default-resource-limitsd.lib `
+                      lib/HLSLd.lib `
+                      lib/MachineIndependentd.lib `
+                      lib/OGLCompilerd.lib `
+                      lib/OSDependentd.lib `
+                      lib/SPIRVd.lib `
+                      lib/SPVRemapperd.lib `
+                      lib/SPIRV-Toolsd.lib `
+                      lib/SPIRV-Tools-optd.lib
+            - name: Zip
+              if: ${{ matrix.cmake_build_type == 'Release' }}
+              env:
+                  ARCHIVE: glslang-master-${{matrix.os.family}}-Release.zip
+              run: |
+                  cd build/install
+                  7z a ${{env.ARCHIVE}} `
+                      bin/glslang.exe `
+                      bin/glslangValidator.exe `
+                      bin/spirv-remap.exe `
+                      include/glslang/* `
+                      lib/GenericCodeGen.lib `
+                      lib/glslang.lib `
+                      lib/glslang-default-resource-limits.lib `
+                      lib/HLSL.lib `
+                      lib/MachineIndependent.lib `
+                      lib/OGLCompiler.lib `
+                      lib/OSDependent.lib `
+                      lib/SPIRV.lib `
+                      lib/SPVRemapper.lib `
+                      lib/SPIRV-Tools.lib `
+                      lib/SPIRV-Tools-opt.lib
+            - name: Deploy
+              env:
                   ARCHIVE: glslang-master-${{matrix.os.family}}-${{matrix.cmake_build_type}}.zip
-              uses: actions/github-script@v5
+              uses: actions/github-script@d7906e4ad0b1822421a7e6a35d5ca353c962f410 # v6.4.1
               with:
                   script: |
                       const script = require('.github/workflows/deploy.js')
diff --git a/.github/workflows/continuous_integration.yml b/.github/workflows/continuous_integration.yml
index 7c36c68..ca0b9a4 100644
--- a/.github/workflows/continuous_integration.yml
+++ b/.github/workflows/continuous_integration.yml
@@ -10,26 +10,28 @@
     workflow_dispatch:
     pull_request:
         branches:
-            - master
+            - main
+
+permissions: read-all
 
 jobs:
     linux:
-        runs-on: ${{matrix.os}}
+        runs-on: ubuntu-22.04
         strategy:
             fail-fast: false
             matrix:
-                os: [ubuntu-20.04]
                 compiler: [{cc: clang, cxx: clang++}, {cc: gcc, cxx: g++}]
                 cmake_build_type: [Debug, Release]
         steps:
-            - uses: actions/checkout@v2
-            - uses: actions/setup-python@v2
+            - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 # v4.1.0
+            - uses: lukka/get-cmake@8be6cca406b575906541e8e3b885d46f416bba39 # v3.27.7
+            - uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
               with:
                   python-version: '3.7'
-            - name: Install Ubuntu Package Dependencies
-              run: |
-                  sudo apt-get -qq update
-                  sudo apt-get install -y clang-6.0
+            - name: Setup ccache
+              uses: hendrikmuhs/ccache-action@6d1841ec156c39a52b1b23a810da917ab98da1f4 # v1.2.10
+              with:
+                  key: ubuntu-22-${{ matrix.cmake_build_type }}-${{ matrix.compiler.cc }}-${{matrix.compiler.cxx}}
             - name: Install GoogleTest
               run: |
                   # check out pre-breakage version of googletest; can be deleted when
@@ -43,35 +45,137 @@
                   git reset --hard FETCH_HEAD
                   cd ../..
             - name: Update Glslang Sources
-              run: |
-                  ./update_glslang_sources.py
-            - name: Build
+              run: ./update_glslang_sources.py
+            - name: Configure
+              run: cmake -S . -B build -D CMAKE_BUILD_TYPE=${{ matrix.cmake_build_type }}
               env:
-                  CC: ${{matrix.compiler.cc}}
-                  CXX: ${{matrix.compiler.cxx}}
-              run: |
-                  mkdir build && cd build
-                  cmake -DCMAKE_BUILD_TYPE=${{matrix.cmake_build_type}} -DCMAKE_INSTALL_PREFIX=`pwd`/install ..
-                  make -j4 install
+                CC: ${{matrix.compiler.cc}}
+                CXX: ${{matrix.compiler.cxx}}
+                CMAKE_GENERATOR: Ninja
+                CMAKE_C_COMPILER_LAUNCHER: ccache
+                CMAKE_CXX_COMPILER_LAUNCHER: ccache
+            - name: Build
+              run: cmake --build build
+            - name: Install
+              run: cmake --install build --prefix build/install
             - name: Test
               run: |
                   cd build
                   ctest --output-on-failure &&
                   cd ../Test && ./runtests
 
+    linux-asan:
+        runs-on: ubuntu-22.04
+        strategy:
+            fail-fast: false
+            matrix:
+                compiler: [{cc: gcc, cxx: g++}]
+                cmake_build_type: [Debug]
+                flags: ['-fsanitize=address', '-fsanitize=thread']
+        steps:
+            - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 # v4.1.0
+            - uses: lukka/get-cmake@8be6cca406b575906541e8e3b885d46f416bba39 # v3.27.7
+            - uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
+              with:
+                  python-version: '3.7'
+            - name: Setup ccache
+              uses: hendrikmuhs/ccache-action@6d1841ec156c39a52b1b23a810da917ab98da1f4 # v1.2.10
+              with:
+                  key: ubuntu-22-${{ matrix.cmake_build_type }}-${{ matrix.compiler.cc }}-${{matrix.compiler.cxx}}-${{matrix.flags}}
+            - name: Install GoogleTest
+              run: |
+                  # check out pre-breakage version of googletest; can be deleted when
+                  # issue 3128 is fixed
+                  # git clone --depth=1 https://github.com/google/googletest.git External/googletest
+                  mkdir -p External/googletest
+                  cd External/googletest
+                  git init
+                  git remote add origin https://github.com/google/googletest.git
+                  git fetch --depth 1 origin 0c400f67fcf305869c5fb113dd296eca266c9725
+                  git reset --hard FETCH_HEAD
+                  cd ../..
+            - name: Update Glslang Sources
+              run: ./update_glslang_sources.py
+            - name: Configure
+              run: cmake -S . -B build -D CMAKE_BUILD_TYPE=${{ matrix.cmake_build_type }}
+              env:
+                CC: ${{matrix.compiler.cc}}
+                CXX: ${{matrix.compiler.cxx}}
+                CMAKE_GENERATOR: Ninja
+                CMAKE_C_COMPILER_LAUNCHER: ccache
+                CMAKE_CXX_COMPILER_LAUNCHER: ccache
+                CFLAGS: ${{matrix.flags}}
+                CXXFLAGS: ${{matrix.flags}}
+                LDFLAGS: ${{matrix.flags}}
+            - name: Build
+              run: cmake --build build
+            - name: Install
+              run: cmake --install build --prefix build/install
+            - name: Test
+              run: |
+                  cd build
+                  ctest --output-on-failure &&
+                  cd ../Test && ./runtests
+
+    # Ensure we can compile/run on an older distro
+    linux_min:
+      name: Linux Backcompat
+      runs-on: ubuntu-20.04
+      steps:
+          - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 # v4.1.0
+          - uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
+            with:
+                python-version: '3.7'
+          - uses: lukka/get-cmake@8be6cca406b575906541e8e3b885d46f416bba39 # v3.27.7
+            with:
+              cmakeVersion: 3.17.2
+          - name: Setup ccache
+            uses: hendrikmuhs/ccache-action@6d1841ec156c39a52b1b23a810da917ab98da1f4 # v1.2.10
+            with:
+              key: linux_backcompat
+          - name: Install GoogleTest
+            run: |
+                # check out pre-breakage version of googletest; can be deleted when
+                # issue 3128 is fixed
+                # git clone --depth=1 https://github.com/google/googletest.git External/googletest
+                mkdir -p External/googletest
+                cd External/googletest
+                git init
+                git remote add origin https://github.com/google/googletest.git
+                git fetch --depth 1 origin 0c400f67fcf305869c5fb113dd296eca266c9725
+                git reset --hard FETCH_HEAD
+                cd ../..
+          - name: Update Glslang Sources
+            run: ./update_glslang_sources.py
+          - name: Configure
+            run: cmake -S . -B build -D CMAKE_BUILD_TYPE=Release
+            env:
+              CMAKE_C_COMPILER_LAUNCHER: ccache
+              CMAKE_CXX_COMPILER_LAUNCHER: ccache
+          - name: Build
+            run: cmake --build build
+          - name: Install
+            run: cmake --install build --prefix build/install
+          - name: Test
+            run: |
+                cd build
+                ctest --output-on-failure &&
+                cd ../Test && ./runtests
+
     macos:
         runs-on: ${{matrix.os}}
         strategy:
             fail-fast: false
             matrix:
-                os: [macos-11]
-                compiler: [{cc: clang, cxx: clang++}]
+                os: [macos-11, macos-12]
+                compiler: [{cc: clang, cxx: clang++}, {cc: gcc, cxx: g++}]
                 cmake_build_type: [Debug, Release]
         steps:
-            - uses: actions/checkout@v2
-            - uses: actions/setup-python@v2
+            - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 # v4.1.0
+            - uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
               with:
                   python-version: '3.7'
+            - uses: lukka/get-cmake@8be6cca406b575906541e8e3b885d46f416bba39 # v3.27.7
             - name: Install GoogleTest
               run: |
                   # check out pre-breakage version of googletest; can be deleted when
@@ -85,49 +189,37 @@
                   git reset --hard FETCH_HEAD
                   cd ../..
             - name: Update Glslang Sources
-              run: |
-                  ./update_glslang_sources.py
-            - name: Build
+              run: ./update_glslang_sources.py
+            - name: Configure
+              run: cmake -S . -B build -D CMAKE_BUILD_TYPE=${{matrix.cmake_build_type}} -G "Ninja"
               env:
                   CC: ${{matrix.compiler.cc}}
                   CXX: ${{matrix.compiler.cxx}}
-              run: |
-                  mkdir build && cd build
-                  cmake -DCMAKE_BUILD_TYPE=${{matrix.cmake_build_type}} -DCMAKE_INSTALL_PREFIX=`pwd`/install ..
-                  make -j4 install
+            - name: Build
+              run: cmake --build build
+            - name: Install
+              run: cmake --install build --prefix build/install
             - name: Test
               run: |
                   cd build
                   ctest --output-on-failure &&
                   cd ../Test && ./runtests
 
-    android:
-        runs-on: ${{matrix.os}}
+    windows:
+        runs-on: ${{matrix.os.genus}}
+        permissions:
+            contents: write
         strategy:
             fail-fast: false
             matrix:
-                os: [ubuntu-20.04]
-                compiler: [{cc: clang, cxx: clang++}]
-                cmake_build_type: [Release]
+                os: [{genus: windows-2019, family: windows}]
+                cmake_build_type: [Debug, Release]
         steps:
-            - uses: actions/checkout@v2
-            - uses: actions/setup-python@v2
+            - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 # v4.1.0
+            - uses: lukka/get-cmake@8be6cca406b575906541e8e3b885d46f416bba39 # v3.27.7
+            - uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
               with:
                   python-version: '3.7'
-            - name: Install Ubuntu Package Dependencies
-              if: ${{matrix.os == 'ubuntu-20.04'}}
-              run: |
-                  sudo apt-get -qq update
-                  sudo apt-get install -y clang-6.0
-            - name: Install Android NDK
-              run: |
-                  export ANDROID_NDK=$HOME/android-ndk
-                  git init $ANDROID_NDK
-                  pushd $ANDROID_NDK
-                  git remote add dneto0 https://github.com/dneto0/android-ndk.git
-                  git fetch --depth=1 dneto0 r17b-strip
-                  git checkout FETCH_HEAD
-                  popd
             - name: Install GoogleTest
               run: |
                   # check out pre-breakage version of googletest; can be deleted when
@@ -142,16 +234,74 @@
                   cd ../..
             - name: Update Glslang Sources
               run: |
-                  ./update_glslang_sources.py
+                  python update_glslang_sources.py
             - name: Build
-              env:
-                  CC: ${{matrix.compiler.cc}}
-                  CXX: ${{matrix.compiler.cxx}}
               run: |
-                  export ANDROID_NDK=$HOME/android-ndk
-                  export TOOLCHAIN_PATH=$ANDROID_NDK/build/cmake/android.toolchain.cmake
-                  echo $ANDROID_NDK
-                  echo $TOOLCHAIN_PATH
-                  mkdir build && cd build
-                  cmake -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_PATH} -DANDROID_NATIVE_API_LEVEL=android-14 -DCMAKE_BUILD_TYPE=${{matrix.cmake_build_type}} -DANDROID_ABI="armeabi-v7a with NEON" -DBUILD_TESTING=OFF ..
-                  make -j4
+                  cmake -S. -Bbuild -G "Visual Studio 16 2019" -A x64 -DCMAKE_INSTALL_PREFIX="$PWD/build/install"
+                  cmake --build build --config ${{matrix.cmake_build_type}} --target install
+            - name: Test
+              run: |
+                  cd build
+                  ctest -C ${{matrix.cmake_build_type}} --output-on-failure
+                  cd ../Test && bash runtests
+
+    android:
+        runs-on: ubuntu-22.04
+        strategy:
+          matrix:
+            # Android NDK currently offers 2 different toolchains.
+            # Test both to ensure we are compatible with either approach.
+            LEGACY: [ON, OFF]
+            # Oldest/newest NDK currently provided by GitHub runners
+            # https://github.com/actions/runner-images/blob/main/images/linux/Ubuntu2204-Readme.md#android
+            NDK: [23.2.8568313, 25.2.9519653]
+        steps:
+            - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 # v4.1.0
+            - uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
+              with:
+                  python-version: '3.7'
+            - uses: lukka/get-cmake@8be6cca406b575906541e8e3b885d46f416bba39 # v3.27.7
+            - name: Setup ccache
+              uses: hendrikmuhs/ccache-action@6d1841ec156c39a52b1b23a810da917ab98da1f4 # v1.2.10
+              with:
+                  key: android-${{ matrix.LEGACY }}-${{ matrix.NDK }}
+            - name: Update Glslang Sources
+              run: ./update_glslang_sources.py
+            - name: Configure
+              run: |
+                cmake -S . -B build/ \
+                --toolchain $ANDROID_HOME/ndk/${{ matrix.NDK }}/build/cmake/android.toolchain.cmake \
+                -D CMAKE_BUILD_TYPE=Release \
+                -D ANDROID_ABI=armeabi-v7a \
+                -D ANDROID_USE_LEGACY_TOOLCHAIN_FILE=${{ matrix.LEGACY }} \
+                -D BUILD_TESTING=OFF
+              env:
+                CMAKE_GENERATOR: Ninja
+                CMAKE_C_COMPILER_LAUNCHER: ccache
+                CMAKE_CXX_COMPILER_LAUNCHER: ccache
+            - name: Build
+              run: cmake --build build/
+
+    emscripten:
+        runs-on: ubuntu-22.04
+        steps:
+            - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 # v4.1.0
+            - uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
+              with:
+                  python-version: '3.7'
+            - uses: lukka/get-cmake@8be6cca406b575906541e8e3b885d46f416bba39 # v3.27.7
+            - name: Setup ccache
+              uses: hendrikmuhs/ccache-action@6d1841ec156c39a52b1b23a810da917ab98da1f4 # v1.2.10
+              with:
+                  key: ubuntu-emscripten
+            - uses: mymindstorm/setup-emsdk@ab889da2abbcbb280f91ec4c215d3bb4f3a8f775 # v12
+            - name: Update Glslang Sources
+              run: ./update_glslang_sources.py
+            - name: Configure
+              run: emcmake cmake -GNinja -Bbuild/web -DCMAKE_BUILD_TYPE=Release -DENABLE_GLSLANG_JS=ON -DBUILD_TESTING=OFF -DENABLE_OPT=OFF
+              env:
+                CMAKE_GENERATOR: Ninja
+                CMAKE_C_COMPILER_LAUNCHER: ccache
+                CMAKE_CXX_COMPILER_LAUNCHER: ccache
+            - name: Build
+              run: cmake --build build/web
diff --git a/.github/workflows/deploy.js b/.github/workflows/deploy.js
index 9f8d242..3f1b7e4 100644
--- a/.github/workflows/deploy.js
+++ b/.github/workflows/deploy.js
@@ -3,11 +3,11 @@
         await github.rest.git.updateRef({
             owner: context.repo.owner,
             repo: context.repo.repo,
-            ref: 'tags/master-tot',
+            ref: 'tags/main-tot',
             sha: context.sha
         })
     } catch (error) {
-        core.setFailed(`upload master-tot tag; ${error.name}; ${error.message}`)
+        core.setFailed(`upload main-tot tag; ${error.name}; ${error.message}`)
     }
 
     let release
@@ -15,10 +15,10 @@
         release = await github.rest.repos.getReleaseByTag({
             owner: context.repo.owner,
             repo: context.repo.repo,
-            tag: 'master-tot'
+            tag: 'main-tot'
         })
     } catch (error) {
-        core.setFailed(`get the master release; ${error.name}; ${error.message}`)
+        core.setFailed(`get the main release; ${error.name}; ${error.message}`)
     }
 
     try {
@@ -28,7 +28,7 @@
             release_id: release.data.id
         })
     } catch (error) {
-        core.setFailed(`update the master release; ${error.name}; ${error.message}`)
+        core.setFailed(`update the main release; ${error.name}; ${error.message}`)
     }
 
     let release_assets
diff --git a/.github/workflows/scorecard.yml b/.github/workflows/scorecard.yml
new file mode 100644
index 0000000..fe3833a
--- /dev/null
+++ b/.github/workflows/scorecard.yml
@@ -0,0 +1,53 @@
+name: Scorecard supply-chain security
+on:
+  # For Branch-Protection check. Only the default branch is supported. See
+  # https://github.com/ossf/scorecard/blob/main/docs/checks.md#branch-protection
+  branch_protection_rule:
+  # To guarantee Maintained check is occasionally updated. See
+  # https://github.com/ossf/scorecard/blob/main/docs/checks.md#maintained
+  schedule:
+    - cron: '36 17 * * 5'
+  push:
+    branches: [ "main" ]
+
+# Declare default permissions as read only.
+permissions: read-all
+
+jobs:
+  analysis:
+    name: Scorecard analysis
+    runs-on: ubuntu-latest
+    permissions:
+      security-events: write # to upload the results to code-scanning dashboard
+      id-token: write # to publish results and get a badge
+
+    steps:
+      - name: "Checkout code"
+        uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 # v4.1.0
+        with:
+          persist-credentials: false
+
+      - name: "Run analysis"
+        uses: ossf/scorecard-action@483ef80eb98fb506c348f7d62e28055e49fe2398 # v2.3.0
+        with:
+          results_file: results.sarif
+          results_format: sarif
+          # To enable Branch-Protection uncomment the `repo_token` line below
+          # To create the Fine-grained PAT, follow the steps in https://github.com/ossf/scorecard-action#authentication-with-fine-grained-pat-optional.
+          # repo_token: ${{ secrets.SCORECARD_TOKEN }}
+          publish_results: true # allows the repo to include the Scorecard badge
+
+      # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF
+      # format to the repository Actions tab.
+      - name: "Upload artifact"
+        uses: actions/upload-artifact@a8a3f3ad30e3422c9c7b888a15615d19a852ae32 # v3.1.3
+        with:
+          name: SARIF file
+          path: results.sarif
+          retention-days: 5
+
+      # Upload the results to GitHub's code scanning dashboard.
+      - name: "Upload to code-scanning"
+        uses: github/codeql-action/upload-sarif@2cb752a87e96af96708ab57187ab6372ee1973ab # v2.22.0
+        with:
+          sarif_file: results.sarif
diff --git a/.gitignore b/.gitignore
index 333fb76..732b345 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,6 +11,7 @@
 External/googletest
 External/spirv-tools
 out/
+CMakeUserPresets.json
 
 # GN generated files
 .cipd/
diff --git a/.mailmap b/.mailmap
new file mode 100644
index 0000000..946b240
--- /dev/null
+++ b/.mailmap
@@ -0,0 +1,3 @@
+Faith Ekstrand <faith.ekstrand@collabora.com> <jason@jlekstrand.net>
+Faith Ekstrand <faith.ekstrand@collabora.com> <jason.ekstrand@intel.com>
+Faith Ekstrand <faith.ekstrand@collabora.com> <jason.ekstrand@collabora.com>
diff --git a/Android.mk b/Android.mk
index 40cddb7..6787a97 100644
--- a/Android.mk
+++ b/Android.mk
@@ -1,4 +1,4 @@
-# Copyright (C) 2020 The Khronos Group Inc.
+# Copyright (C) 2020-2023 The Khronos Group Inc.
 #
 # All rights reserved.
 #
@@ -53,11 +53,11 @@
 
 GLSLANG_OS_FLAGS := -DGLSLANG_OSINCLUDE_UNIX
 # AMD and NV extensions are turned on by default in upstream Glslang.
-GLSLANG_DEFINES:= -DAMD_EXTENSIONS -DNV_EXTENSIONS -DENABLE_HLSL $(GLSLANG_OS_FLAGS)
+GLSLANG_DEFINES:= -DENABLE_HLSL $(GLSLANG_OS_FLAGS)
 
 include $(CLEAR_VARS)
 LOCAL_MODULE:=OSDependent
-LOCAL_CXXFLAGS:=-std=c++11 -fno-exceptions -fno-rtti $(GLSLANG_DEFINES)
+LOCAL_CXXFLAGS:=-std=c++17 -fno-exceptions -fno-rtti $(GLSLANG_DEFINES)
 LOCAL_EXPORT_C_INCLUDES:=$(LOCAL_PATH)
 LOCAL_SRC_FILES:=glslang/OSDependent/Unix/ossource.cpp
 LOCAL_C_INCLUDES:=$(LOCAL_PATH) $(LOCAL_PATH)/glslang/OSDependent/Unix/
@@ -66,7 +66,7 @@
 
 include $(CLEAR_VARS)
 LOCAL_MODULE:=OGLCompiler
-LOCAL_CXXFLAGS:=-std=c++11 -fno-exceptions -fno-rtti $(GLSLANG_DEFINES)
+LOCAL_CXXFLAGS:=-std=c++17 -fno-exceptions -fno-rtti $(GLSLANG_DEFINES)
 LOCAL_EXPORT_C_INCLUDES:=$(LOCAL_PATH)
 LOCAL_SRC_FILES:=OGLCompilersDLL/InitializeDll.cpp
 LOCAL_C_INCLUDES:=$(LOCAL_PATH)/OGLCompiler
@@ -78,7 +78,7 @@
 # instead.
 include $(CLEAR_VARS)
 LOCAL_MODULE:=HLSL
-LOCAL_CXXFLAGS:=-std=c++11 -fno-exceptions -fno-rtti $(GLSLANG_DEFINES)
+LOCAL_CXXFLAGS:=-std=c++17 -fno-exceptions -fno-rtti $(GLSLANG_DEFINES)
 LOCAL_SRC_FILES:= \
 	hlsl/stub.cpp
 LOCAL_C_INCLUDES:=$(LOCAL_PATH) \
@@ -93,7 +93,7 @@
 	$(GLSLANG_BUILD_INFO_H)
 
 LOCAL_MODULE:=glslang
-LOCAL_CXXFLAGS:=-std=c++11 -fno-exceptions -fno-rtti $(GLSLANG_DEFINES)
+LOCAL_CXXFLAGS:=-std=c++17 -fno-exceptions -fno-rtti $(GLSLANG_DEFINES)
 LOCAL_EXPORT_C_INCLUDES:=$(LOCAL_PATH)
 LOCAL_SRC_FILES:= \
 		glslang/CInterface/glslang_c_interface.cpp \
@@ -148,7 +148,7 @@
 	$(GLSLANG_BUILD_INFO_H)
 
 LOCAL_MODULE:=SPIRV
-LOCAL_CXXFLAGS:=-std=c++11 -fno-exceptions -fno-rtti -Werror $(GLSLANG_DEFINES)
+LOCAL_CXXFLAGS:=-std=c++17 -fno-exceptions -fno-rtti -Werror $(GLSLANG_DEFINES)
 LOCAL_SRC_FILES:= \
 	SPIRV/CInterface/spirv_c_interface.cpp \
 	SPIRV/GlslangToSpv.cpp \
diff --git a/BUILD.bazel b/BUILD.bazel
deleted file mode 100644
index 12168fa..0000000
--- a/BUILD.bazel
+++ /dev/null
@@ -1,311 +0,0 @@
-# Copyright (C) 2020 The Khronos Group Inc.
-#
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-#
-#    Redistributions of source code must retain the above copyright
-#    notice, this list of conditions and the following disclaimer.
-#
-#    Redistributions in binary form must reproduce the above
-#    copyright notice, this list of conditions and the following
-#    disclaimer in the documentation and/or other materials provided
-#    with the distribution.
-#
-#    Neither the name of The Khronos Group Inc. nor the names of its
-#    contributors may be used to endorse or promote products derived
-#    from this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-# COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-# POSSIBILITY OF SUCH DAMAGE.
-
-package(
-    default_visibility = ["//visibility:public"],
-)
-
-# Description:
-#
-# Khronos reference front-end for GLSL and ESSL, and sample SPIR-V generator.
-
-licenses(["notice"])
-
-exports_files(["LICENSE"])
-
-# Build information generation script
-py_binary(
-    name = "build_info",
-    srcs = ["build_info.py"],
-)
-
-py_binary(
-    name = "gen_extension_headers",
-    srcs = ["gen_extension_headers.py"],
-)
-
-genrule(
-    name = "gen_build_info_h",
-    srcs = ["CHANGES.md", "build_info.h.tmpl"],
-    outs = ["glslang/build_info.h"],
-    cmd_bash = "$(location build_info) $$(dirname $(location CHANGES.md)) -i $(location build_info.h.tmpl) -o $(location glslang/build_info.h)",
-    cmd_bat = "for %F in ($(location CHANGES.md)) do $(location build_info) %~dpF -i $(location build_info.h.tmpl) -o $(location glslang/build_info.h)",
-    tools = [":build_info"],
-)
-
-genrule(
-    name = "gen_extension_headers_h",
-    srcs = ["glslang/ExtensionHeaders", "gen_extension_headers.py"],
-    outs = ["glslang/glsl_intrinsic_header.h"],
-    cmd_bash = "$(location gen_extension_headers) -i  $(location glslang/ExtensionHeaders) -o $(location glslang/glsl_intrinsic_header.h)",
-    tools = [":gen_extension_headers"],
-)
-
-COMMON_COPTS = select({
-    "@bazel_tools//src/conditions:windows": [""],
-    "//conditions:default": [
-        "-Wall",
-        "-Wuninitialized",
-        "-Wunused",
-        "-Wunused-local-typedefs",
-        "-Wunused-parameter",
-        "-Wunused-value",
-        "-Wunused-variable",
-        "-Wno-reorder",
-        "-std=c++11",
-        "-fvisibility=hidden",
-        "-fvisibility-inlines-hidden",
-        "-fno-exceptions",
-        "-fno-rtti",
-    ],
-})
-
-cc_library(
-    name = "glslang",
-    srcs = glob(
-        [
-            "glslang/GenericCodeGen/*.cpp",
-            "glslang/HLSL/*.cpp",
-            "glslang/MachineIndependent/*.cpp",
-            "glslang/MachineIndependent/preprocessor/*.cpp",
-        ],
-        exclude = [
-            "glslang/HLSL/pch.h",
-            "glslang/MachineIndependent/pch.h",
-        ],
-    ) + [
-        "OGLCompilersDLL/InitializeDll.cpp",
-    ] + select({
-        "@bazel_tools//src/conditions:windows":
-            ["glslang/OSDependent/Windows/ossource.cpp"],
-        "//conditions:default":
-            ["glslang/OSDependent/Unix/ossource.cpp"],
-    }),
-    hdrs = glob([
-        "glslang/HLSL/*.h",
-        "glslang/Include/*.h",
-        "glslang/MachineIndependent/*.h",
-        "glslang/MachineIndependent/preprocessor/*.h",
-    ]) + [
-        "OGLCompilersDLL/InitializeDll.h",
-        "StandAlone/DirStackFileIncluder.h",
-        "glslang/OSDependent/osinclude.h",
-        "glslang/Public/ShaderLang.h",
-        ":gen_build_info_h",
-    ],
-    copts = COMMON_COPTS,
-    defines = [
-        "AMD_EXTENSIONS",
-        "ENABLE_HLSL=0",
-        "ENABLE_OPT=0",
-        "NV_EXTENSIONS",
-    ],
-    linkopts = select({
-        "@bazel_tools//src/conditions:windows": [""],
-        "//conditions:default": ["-lm", "-lpthread"],
-    }),
-    linkstatic = 1,
-)
-
-genrule(
-    name = "export_spirv_headers",
-    srcs = [
-        "SPIRV/GLSL.ext.AMD.h",
-        "SPIRV/GLSL.ext.EXT.h",
-        "SPIRV/GLSL.ext.KHR.h",
-        "SPIRV/GLSL.ext.NV.h",
-        "SPIRV/GLSL.std.450.h",
-        "SPIRV/NonSemanticDebugPrintf.h",
-        "SPIRV/NonSemanticShaderDebugInfo100.h",
-        "SPIRV/spirv.hpp",
-    ],
-    outs = [
-        "include/SPIRV/GLSL.ext.AMD.h",
-        "include/SPIRV/GLSL.ext.EXT.h",
-        "include/SPIRV/GLSL.ext.KHR.h",
-        "include/SPIRV/GLSL.ext.NV.h",
-        "include/SPIRV/GLSL.std.450.h",
-        "include/SPIRV/NonSemanticDebugPrintf.h",
-        "include/SPIRV/NonSemanticShaderDebugInfo100.h",
-        "include/SPIRV/spirv.hpp",
-    ],
-    cmd_bash = "mkdir -p $(@D)/include/SPIRV && cp $(SRCS) $(@D)/include/SPIRV/",
-    cmd_bat = "(if not exist $(@D)\\include\\SPIRV mkdir $(@D)\\include\\SPIRV) && (for %S in ($(SRCS)) do @xcopy /q %S $(@D)\\include\\SPIRV\\ >NUL)",
-)
-
-cc_library(
-    name = "SPIRV_headers",
-    hdrs = [":export_spirv_headers"],
-    copts = COMMON_COPTS,
-    includes = [
-        "include",
-        "include/SPIRV",
-    ],
-    linkstatic = 1,
-)
-
-cc_library(
-    name = "SPIRV",
-    srcs = glob(
-        ["SPIRV/*.cpp"],
-        exclude = [
-            "SPIRV/SpvTools.cpp",
-        ],
-    ),
-    hdrs = [
-        "SPIRV/GlslangToSpv.h",
-        "SPIRV/Logger.h",
-        "SPIRV/SPVRemapper.h",
-        "SPIRV/SpvBuilder.h",
-        "SPIRV/SpvTools.h",
-        "SPIRV/bitutils.h",
-        "SPIRV/disassemble.h",
-        "SPIRV/doc.h",
-        "SPIRV/hex_float.h",
-        "SPIRV/spvIR.h",
-    ],
-    copts = COMMON_COPTS,
-    includes = ["SPIRV"],
-    linkopts = select({
-        "@bazel_tools//src/conditions:windows": [""],
-        "//conditions:default": ["-lm"],
-    }),
-    linkstatic = 1,
-    deps = [
-        ":SPIRV_headers",
-        ":glslang",
-    ],
-)
-
-cc_library(
-    name = "glslang-default-resource-limits",
-    srcs = ["StandAlone/ResourceLimits.cpp"],
-    hdrs = ["StandAlone/ResourceLimits.h"],
-    copts = COMMON_COPTS,
-    linkstatic = 1,
-    deps = [":glslang"],
-)
-
-cc_binary(
-    name = "glslangValidator",
-    srcs = [
-        "StandAlone/StandAlone.cpp",
-        "StandAlone/Worklist.h",
-        ":glslang/glsl_intrinsic_header.h"
-    ],
-    copts = COMMON_COPTS,
-    deps = [
-        ":SPIRV",
-        ":glslang",
-        ":glslang-default-resource-limits",
-    ],
-)
-
-cc_binary(
-    name = "spirv-remap",
-    srcs = ["StandAlone/spirv-remap.cpp"],
-    copts = COMMON_COPTS,
-    deps = [
-        ":SPIRV",
-        ":glslang",
-        ":glslang-default-resource-limits",
-    ],
-)
-
-filegroup(
-    name = "test_files",
-    srcs = glob(
-        ["Test/**"],
-        exclude = [
-            "Test/bump",
-            "Test/glslangValidator",
-            "Test/runtests",
-        ],
-    ),
-)
-
-cc_library(
-    name = "glslang_test_lib",
-    testonly = 1,
-    srcs = [
-        "gtests/HexFloat.cpp",
-        "gtests/Initializer.h",
-        "gtests/Settings.cpp",
-        "gtests/Settings.h",
-        "gtests/TestFixture.cpp",
-        "gtests/TestFixture.h",
-        "gtests/main.cpp",
-    ],
-    copts = COMMON_COPTS,
-    data = [":test_files"],
-    defines = select({
-        # Unfortunately we can't use $(location) in cc_library at the moment.
-        # See https://github.com/bazelbuild/bazel/issues/1023
-        # So we'll specify the path manually.
-        "@bazel_tools//src/conditions:windows":
-            ["GLSLANG_TEST_DIRECTORY='\"../../../../../Test\"'"],
-        "//conditions:default":
-            ["GLSLANG_TEST_DIRECTORY='\"Test\"'"],
-    }),
-    linkstatic = 1,
-    deps = [
-        ":SPIRV",
-        ":glslang",
-        ":glslang-default-resource-limits",
-        "@com_google_googletest//:gtest",
-    ],
-)
-
-GLSLANG_TESTS = glob(
-    ["gtests/*.FromFile.cpp"],
-    # Since we are not building the SPIRV-Tools dependency, the following tests
-    # cannot be performed.
-    exclude = [
-        "gtests/Hlsl.FromFile.cpp",
-        "gtests/Spv.FromFile.cpp",
-    ],
-)
-
-[cc_test(
-    name = test_file.replace("gtests/", "").replace(".FromFile.cpp", "") + "_test",
-    srcs = [test_file],
-    copts = COMMON_COPTS,
-    data = [
-        ":test_files",
-    ],
-    deps = [
-        ":SPIRV",
-        ":glslang",
-        ":glslang_test_lib",
-    ],
-) for test_file in GLSLANG_TESTS]
diff --git a/BUILD.gn b/BUILD.gn
index 67a1aa4..985da51 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -99,9 +99,13 @@
   # https://fuchsia.dev/fuchsia-src/development/build/hermetic_actions
   # for details). All input files of the script should be added to the
   # |sources| list.
-  sources = [ "glslang/ExtensionHeaders/GL_EXT_shader_realtime_clock.glsl" ]
+  sources = [
+    "glslang/ExtensionHeaders/GL_EXT_shader_realtime_clock.glsl",
+  ]
 
-  inputs = [ script ]
+  inputs = [
+    script
+  ]
   outputs = [ out_file ]
   args = [
     "-i",
@@ -112,9 +116,6 @@
 }
 
 spirv_tools_dir = glslang_spirv_tools_dir
-if (!defined(glslang_angle)) {
-  glslang_angle = false
-}
 
 config("glslang_public") {
   include_dirs = [ "." ]
@@ -144,6 +145,8 @@
       "SPIRV/GLSL.ext.EXT.h",
       "SPIRV/GLSL.ext.KHR.h",
       "SPIRV/GLSL.ext.NV.h",
+      "SPIRV/GLSL.ext.ARM.h",
+      "SPIRV/GLSL.ext.QCOM.h",
       "SPIRV/GLSL.std.450.h",
       "SPIRV/GlslangToSpv.cpp",
       "SPIRV/GlslangToSpv.h",
@@ -260,9 +263,6 @@
       sources += [ "SPIRV/SpvTools.cpp" ]
       defines += [ "ENABLE_OPT=1" ]
     }
-    if (invoker.is_angle) {
-      defines += [ "GLSLANG_ANGLE" ]
-    }
 
     if (is_win) {
       sources += [ "glslang/OSDependent/Windows/ossource.cpp" ]
@@ -318,21 +318,19 @@
 }
 
 glslang_sources_common("glslang_lib_sources") {
-  enable_opt = !glslang_angle
-  enable_hlsl = !glslang_angle
-  is_angle = glslang_angle
+  enable_opt = true
+  enable_hlsl = true
 }
 
 glslang_sources_common("glslang_sources") {
   enable_opt = true
   enable_hlsl = true
-  is_angle = false
 }
 
 source_set("glslang_default_resource_limits_sources") {
   sources = [
-    "StandAlone/ResourceLimits.cpp",
-    "StandAlone/ResourceLimits.h",
+    "glslang/ResourceLimits/ResourceLimits.cpp",
+    "glslang/Public/ResourceLimits.h",
     "glslang/Include/ResourceLimits.h",
   ]
   public_configs = [ ":glslang_public" ]
diff --git a/CHANGES.md b/CHANGES.md
index e7b6f14..8a97ff4 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -3,6 +3,98 @@
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](https://semver.org/).
 
+## 13.1.1 2023-10-16
+* Initialize compile_only field in C interface
+
+## 13.1.0 2023-10-13
+* Support GL_EXT_texture_shadow_lod
+* Support GL_NV_displacement_micromap
+* Fix ByteAddressBuffer when used a function parameter
+* Add more verbose messages if SPIRV-Tools is not found
+* Fix names for explicitly sized types when emitting nonsemantic debug info
+* Emit error for r-value arguments in atomic memory operations
+* Add --no-link option
+* Beautify preprocessor output format
+* Fix race condition in glslangValidator
+* Only set LocalSizeId mode when necessary
+* Don't emit invalid debug info for buffer references
+
+## 13.0.0 2023-08-23
+
+### Breaking changes
+* Simplify PoolAlloc via thread_local
+  * Remove InitializeDLL functions
+  * Remove OSDependent TLS functions
+* Remove GLSLANG_WEB and GLSLANG_WEB_DEVEL code paths
+
+### Other changes
+* Raise CMAKE minimum to 3.17.2
+* Support GL_KHR_cooperative_matrix 
+* Support GL_QCOM_image_processing_support
+* Support outputting each module to a filename with spirv-remap
+* Generate an error when gl_PrimitiveShaderRateEXT is used without enabling the extension
+* Improve layout checking when GL_EXT_spirv_intrinsics is enabled
+
+## 12.3.1 2023-07-20
+
+### Other changes
+* Improve backward compatibility for glslangValidator rename on Windows
+
+## 12.3.0 2023-07-19
+
+### Other changes
+* Rename glslangValidator to glslang and create glslangValidator symlink
+* Support HLSL binary literals
+* Add missing initialization members for web
+* Improve push_constant upgrading
+* Fix race condition in spirv remap
+* Support pre and post HLSL qualifier validation
+* Force generateDebugInfo when non-semantic debug info is enabled
+* Exit with error if output file cannot be written
+* Fix struct member buffer reference decorations
+
+## 12.2.0 2023-05-17
+
+### Other changes
+* Support GLSL_EXT_shader_tile_image
+* Support GL_EXT_ray_tracing_position_fetch
+* Support custom include callbacks via the C API
+* Add preamble-text command-line option
+* Accept variables as parameters of spirv_decorate_id
+* Fix generation of conditionals with a struct result
+* Fix double expansion of macros
+* Fix DebugCompilationUnit scope
+* Improve line information
+
+## 12.1.0 2023-03-21
+
+### Other changes
+* Reject non-float inputs/outputs for version less than 120
+* Fix invalid BufferBlock decoration for SPIR-V 1.3 and above
+* Add HLSL relaxed-precision float/int matrix expansions
+* Block decorate Vulkan structs with RuntimeArrays
+* Support InterlockedAdd on float types
+
+## 12.0.0 2023-01-18
+
+### Breaking changes
+* An ABI was accidentally broken in #3014. Consequently, we have incremented the major revision number.
+
+### Other changes
+* Add support for ARB_bindless_texture.
+* Add support for GL_NV_shader_invocation_reorder.
+* Fix const parameter debug types when using NonSemantic.Shader.DebugInfo.100.
+* Fix NonSemantic.Shader.DebugInfo.100 disassembly.
+* Fix MaxDualSourceDrawBuffersEXT usage.
+* Fix structure member reference crash.
+
+## 11.13.0 2022-12-06
+
+### Other changes
+* Make HelperInvocation accesses volatile for SPIR-V 1.6.
+* Improve forward compatibility of ResourceLimits interface 
+* Remove GLSLANG_ANGLE
+
 ## 11.12.0 2022-10-12
 
 ### Other changes
diff --git a/CMakeLists.txt b/CMakeLists.txt
index b581c84..a734ad1 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (C) 2020 The Khronos Group Inc.
+# Copyright (C) 2020-2023 The Khronos Group Inc.
 #
 # All rights reserved.
 #
@@ -30,24 +30,11 @@
 # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 # POSSIBILITY OF SUCH DAMAGE.
-
-# increase to 3.1 once all major distributions
-# include a version of CMake >= 3.1
-cmake_minimum_required(VERSION 3.14.0)
-if (POLICY CMP0048)
-  cmake_policy(SET CMP0048 NEW)
-endif()
-if(POLICY CMP0054)
-  cmake_policy(SET CMP0054 NEW)
-endif()
-
-project(glslang LANGUAGES CXX)
+cmake_minimum_required(VERSION 3.17.2)
+project(glslang)
 
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
-# Enable compile commands database
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
-
 # Adhere to GNU filesystem layout conventions
 include(GNUInstallDirs)
 include(CMakePackageConfigHelpers)
@@ -78,18 +65,10 @@
 endif()
 option(ENABLE_SPVREMAPPER "Enables building of SPVRemapper" ON)
 
-option(ENABLE_GLSLANG_BINARIES "Builds glslangValidator and spirv-remap" ON)
+option(ENABLE_GLSLANG_BINARIES "Builds glslang and spirv-remap" ON)
 
 option(ENABLE_GLSLANG_JS
     "If using Emscripten, build glslang.js. Otherwise, builds a sample executable for binary-size testing." OFF)
-CMAKE_DEPENDENT_OPTION(ENABLE_GLSLANG_WEBMIN
-    "Reduces glslang to minimum needed for web use"
-    OFF "ENABLE_GLSLANG_JS"
-    OFF)
-CMAKE_DEPENDENT_OPTION(ENABLE_GLSLANG_WEBMIN_DEVEL
-    "For ENABLE_GLSLANG_WEBMIN builds, enables compilation error messages"
-    OFF "ENABLE_GLSLANG_WEBMIN"
-    OFF)
 CMAKE_DEPENDENT_OPTION(ENABLE_EMSCRIPTEN_SINGLE_FILE
     "If using Emscripten, enables SINGLE_FILE build"
     OFF "ENABLE_GLSLANG_JS AND EMSCRIPTEN"
@@ -99,11 +78,7 @@
     OFF "ENABLE_GLSLANG_JS AND EMSCRIPTEN"
     OFF)
 
-CMAKE_DEPENDENT_OPTION(ENABLE_HLSL
-    "Enables HLSL input support"
-    ON "NOT ENABLE_GLSLANG_WEBMIN"
-    OFF)
-
+option(ENABLE_HLSL "Enables HLSL input support" ON)
 option(ENABLE_RTTI "Enables RTTI" OFF)
 option(ENABLE_EXCEPTIONS "Enables Exceptions" OFF)
 option(ENABLE_OPT "Enables spirv-opt capability if present" ON)
@@ -117,18 +92,6 @@
 endif()
 option(ENABLE_CTEST "Enables testing" ON)
 
-if(ENABLE_GLSLANG_INSTALL AND CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT AND WIN32)
-    set(CMAKE_INSTALL_PREFIX "install" CACHE STRING "..." FORCE)
-endif()
-
-option(USE_CCACHE "Use ccache" OFF)
-if(USE_CCACHE)
-    find_program(CCACHE_FOUND ccache)
-    if(CCACHE_FOUND)
-        set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
-    endif()
-endif()
-
 if(ENABLE_CTEST)
     include(CTest)
 endif()
@@ -137,13 +100,6 @@
     add_definitions(-DENABLE_HLSL)
 endif()
 
-if(ENABLE_GLSLANG_WEBMIN)
-    add_definitions(-DGLSLANG_WEB)
-    if(ENABLE_GLSLANG_WEBMIN_DEVEL)
-        add_definitions(-DGLSLANG_WEB_DEVEL)
-    endif()
-endif()
-
 if(WIN32)
     set(CMAKE_DEBUG_POSTFIX "d")
     option(OVERRIDE_MSVCCRT "Overrides runtime of MSVC " ON)
@@ -151,7 +107,7 @@
         include(ChooseMSVCCRT.cmake)
     endif()
     add_definitions(-DGLSLANG_OSINCLUDE_WIN32)
-elseif(UNIX)
+elseif(UNIX OR ANDROID)
     add_definitions(-DGLSLANG_OSINCLUDE_UNIX)
 else()
     message("unknown platform")
@@ -160,7 +116,6 @@
 if(${CMAKE_CXX_COMPILER_ID} MATCHES "GNU")
     add_compile_options(-Wall -Wmaybe-uninitialized -Wuninitialized -Wunused -Wunused-local-typedefs
                         -Wunused-parameter -Wunused-value  -Wunused-variable -Wunused-but-set-parameter -Wunused-but-set-variable -fno-exceptions)
-    add_compile_options(-Wno-reorder)  # disable this from -Wall, since it happens all over.
     if(NOT ENABLE_RTTI)
         add_compile_options(-fno-rtti)
     endif()
@@ -171,16 +126,13 @@
         add_compile_options(-Werror=deprecated-copy)
     endif()
 
-    if(NOT CMAKE_VERSION VERSION_LESS "3.13" AND NOT CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+    if(NOT CMAKE_SYSTEM_NAME STREQUAL "OpenBSD" AND NOT CMAKE_SYSTEM_NAME STREQUAL "Darwin")
         # Error if there's symbols that are not found at link time.
-        # add_link_options() was added in CMake 3.13 - if using an earlier
-        # version don't set this - it should be caught by presubmits anyway.
         add_link_options("-Wl,--no-undefined")
     endif()
 elseif(${CMAKE_CXX_COMPILER_ID} MATCHES "Clang" AND NOT MSVC)
     add_compile_options(-Wall -Wuninitialized -Wunused -Wunused-local-typedefs
                         -Wunused-parameter -Wunused-value  -Wunused-variable)
-    add_compile_options(-Wno-reorder)  # disable this from -Wall, since it happens all over.
     if(NOT ENABLE_RTTI)
         add_compile_options(-fno-rtti)
     endif()
@@ -188,14 +140,12 @@
         add_compile_options(-fno-exceptions)
     endif()
 
-    if(NOT CMAKE_VERSION VERSION_LESS "3.13")
-        # Error if there's symbols that are not found at link time.
-        # add_link_options() was added in CMake 3.13 - if using an earlier
-        # version don't set this - it should be caught by presubmits anyway.
-        if (WIN32)
-            add_link_options("-Wl,--no-undefined")
-        else()
+    if(NOT (CMAKE_SYSTEM_NAME STREQUAL "OpenBSD" OR CMAKE_SYSTEM_NAME STREQUAL "Emscripten"))
+        # Error if there's symbols that are not found at link time. Some linkers do not support this flag.
+        if (CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
             add_link_options("-Wl,-undefined,error")
+        elseif(NOT APPLE)
+            add_link_options("-Wl,--no-undefined")
         endif()
     endif()
 elseif(MSVC)
@@ -227,21 +177,16 @@
     endif()
 endif()
 
-# Request C++11
-if(${CMAKE_VERSION} VERSION_LESS 3.1)
-    # CMake versions before 3.1 do not understand CMAKE_CXX_STANDARD
-    # remove this block once CMake >=3.1 has fixated in the ecosystem
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
-else()
-    set(CMAKE_CXX_STANDARD 11)
-    set(CMAKE_CXX_STANDARD_REQUIRED ON)
-    set(CMAKE_CXX_EXTENSIONS OFF)
-endif()
+# Request C++17
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
 
 function(glslang_set_link_args TARGET)
     # For MinGW compiles, statically link against the GCC and C++ runtimes.
     # This avoids the need to ship those runtimes as DLLs.
-    if(WIN32 AND ${CMAKE_CXX_COMPILER_ID} MATCHES "GNU")
+    # This is supported by GCC and Clang.
+    if(WIN32 AND NOT MSVC)
         set_target_properties(${TARGET} PROPERTIES
                               LINK_FLAGS "-static -static-libgcc -static-libstdc++")
     endif()
@@ -289,10 +234,9 @@
 function(glslang_only_export_explicit_symbols target)
     if(BUILD_SHARED_LIBS)
         target_compile_definitions(${target} PUBLIC "GLSLANG_IS_SHARED_LIBRARY=1")
+        set_target_properties(${target} PROPERTIES CMAKE_CXX_VISIBILITY_PRESET hidden)
         if(WIN32)
             target_compile_definitions(${target} PRIVATE "GLSLANG_EXPORTING=1")
-        else()
-            target_compile_options(${target} PRIVATE "-fvisibility=hidden")
         endif()
     endif()
 endfunction()
@@ -313,14 +257,30 @@
 endif()
 
 if(BUILD_EXTERNAL AND IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/External)
-    find_host_package(PythonInterp 3 REQUIRED)
+    find_host_package(Python3 REQUIRED)
 
     # We depend on these for later projects, so they should come first.
     add_subdirectory(External)
 endif()
 
+option(ALLOW_EXTERNAL_SPIRV_TOOLS "Allows to build against installed SPIRV-Tools-opt" OFF)
 if(NOT TARGET SPIRV-Tools-opt)
-    set(ENABLE_OPT OFF)
+    if(ALLOW_EXTERNAL_SPIRV_TOOLS)
+        # Look for external SPIR-V Tools build, if not building in-tree
+        message(STATUS "Trying to find local SPIR-V tools")
+        find_package(SPIRV-Tools-opt)
+        if(NOT TARGET SPIRV-Tools-opt)
+            if(ENABLE_OPT)
+                message(WARNING "ENABLE_OPT set but SPIR-V tools not found! Disabling SPIR-V optimization.")
+            endif()
+            set(ENABLE_OPT OFF)
+        endif()
+    else()
+        if(ENABLE_OPT)
+            message(SEND_ERROR "ENABLE_OPT set but SPIR-V tools not found. Please run update_glslang_sources.py, "
+                "set the ALLOW_EXTERNAL_SPIRV_TOOLS option to use a local install of SPIRV-Tools, or set ENABLE_OPT=0.")
+        endif()
+    endif()
 endif()
 
 if(ENABLE_OPT)
@@ -355,12 +315,12 @@
     endif()
 
     if (CMAKE_CONFIGURATION_TYPES)
-        set(RESULTS_PATH ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIGURATION>/localResults)
-        set(VALIDATOR_PATH ${CMAKE_CURRENT_BINARY_DIR}/StandAlone/$<CONFIGURATION>/glslangValidator)
-        set(REMAP_PATH ${CMAKE_CURRENT_BINARY_DIR}/StandAlone/$<CONFIGURATION>/spirv-remap)
+        set(RESULTS_PATH ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>/localResults)
+        set(VALIDATOR_PATH ${CMAKE_CURRENT_BINARY_DIR}/StandAlone/$<CONFIG>/glslang)
+        set(REMAP_PATH ${CMAKE_CURRENT_BINARY_DIR}/StandAlone/$<CONFIG>/spirv-remap)
     else()
         set(RESULTS_PATH ${CMAKE_CURRENT_BINARY_DIR}/localResults)
-        set(VALIDATOR_PATH ${CMAKE_CURRENT_BINARY_DIR}/StandAlone/glslangValidator)
+        set(VALIDATOR_PATH ${CMAKE_CURRENT_BINARY_DIR}/StandAlone/glslang)
         set(REMAP_PATH ${CMAKE_CURRENT_BINARY_DIR}/StandAlone/spirv-remap)
     endif()
 
@@ -372,10 +332,18 @@
 if(ENABLE_GLSLANG_INSTALL)
     file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/glslang-config.cmake.in" [=[
         @PACKAGE_INIT@
+        @INSTALL_CONFIG_UNIX@
         include("@PACKAGE_PATH_EXPORT_TARGETS@")
     ]=])
-    
+
     set(PATH_EXPORT_TARGETS "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}/glslang-targets.cmake")
+    if(UNIX OR "${CMAKE_SYSTEM_NAME}" STREQUAL "Fuchsia")
+        set(INSTALL_CONFIG_UNIX [=[
+            include(CMakeFindDependencyMacro)
+            set(THREADS_PREFER_PTHREAD_FLAG ON)
+            find_dependency(Threads REQUIRED)
+        ]=])
+    endif()
     configure_package_config_file(
         "${CMAKE_CURRENT_BINARY_DIR}/glslang-config.cmake.in"
         "${CMAKE_CURRENT_BINARY_DIR}/glslang-config.cmake"
@@ -383,18 +351,18 @@
             PATH_EXPORT_TARGETS
         INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
     )
-    
+
     write_basic_package_version_file("${CMAKE_CURRENT_BINARY_DIR}/glslang-config-version.cmake"
         VERSION ${GLSLANG_VERSION}
         COMPATIBILITY SameMajorVersion
     )
-    
+
     install(
         EXPORT      glslang-targets
         NAMESPACE   "glslang::"
         DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
     )
-    
+
     install(
         FILES
             "${CMAKE_CURRENT_BINARY_DIR}/glslang-config.cmake"
@@ -402,4 +370,4 @@
         DESTINATION
             "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
     )
-endif()
\ No newline at end of file
+endif()
diff --git a/OGLCompilersDLL/CMakeLists.txt b/OGLCompilersDLL/CMakeLists.txt
index b44cbc7..71a5675 100644
--- a/OGLCompilersDLL/CMakeLists.txt
+++ b/OGLCompilersDLL/CMakeLists.txt
@@ -49,7 +49,7 @@
         message(WARNING \"Using `OGLCompilerTargets.cmake` is deprecated: use `find_package(glslang)` to find glslang CMake targets.\")
 
         if (NOT TARGET glslang::OGLCompiler)
-            include(\"\${CMAKE_CURRENT_LIST_DIR}/../../${CMAKE_INSTALL_LIBDIR}/${PROJECT_NAME}/glslang-targets.cmake\")
+            include(\"${CMAKE_INSTALL_FULL_LIBDIR}/cmake/${PROJECT_NAME}/glslang-targets.cmake\")
         endif()
 
         add_library(OGLCompiler ALIAS glslang::OGLCompiler)
diff --git a/OGLCompilersDLL/InitializeDll.cpp b/OGLCompilersDLL/InitializeDll.cpp
index abea910..ab3762e 100644
--- a/OGLCompilersDLL/InitializeDll.cpp
+++ b/OGLCompilersDLL/InitializeDll.cpp
@@ -32,134 +32,6 @@
 // POSSIBILITY OF SUCH DAMAGE.
 //
 
-#define SH_EXPORTING
-
-#include <cassert>
-
-#include "InitializeDll.h"
-#include "../glslang/Include/InitializeGlobals.h"
-#include "../glslang/Public/ShaderLang.h"
-#include "../glslang/Include/PoolAlloc.h"
-
 namespace glslang {
 
-OS_TLSIndex ThreadInitializeIndex = OS_INVALID_TLS_INDEX;
-
-// Per-process initialization.
-// Needs to be called at least once before parsing, etc. is done.
-// Will also do thread initialization for the calling thread; other
-// threads will need to do that explicitly.
-bool InitProcess()
-{
-    glslang::GetGlobalLock();
-
-    if (ThreadInitializeIndex != OS_INVALID_TLS_INDEX) {
-        //
-        // Function is re-entrant.
-        //
-
-        glslang::ReleaseGlobalLock();
-        return true;
-    }
-
-    ThreadInitializeIndex = OS_AllocTLSIndex();
-
-    if (ThreadInitializeIndex == OS_INVALID_TLS_INDEX) {
-        assert(0 && "InitProcess(): Failed to allocate TLS area for init flag");
-
-        glslang::ReleaseGlobalLock();
-        return false;
-    }
-
-    if (! InitializePoolIndex()) {
-        assert(0 && "InitProcess(): Failed to initialize global pool");
-
-        glslang::ReleaseGlobalLock();
-        return false;
-    }
-
-    if (! InitThread()) {
-        assert(0 && "InitProcess(): Failed to initialize thread");
-
-        glslang::ReleaseGlobalLock();
-        return false;
-    }
-
-    glslang::ReleaseGlobalLock();
-    return true;
-}
-
-// Per-thread scoped initialization.
-// Must be called at least once by each new thread sharing the
-// symbol tables, etc., needed to parse.
-bool InitThread()
-{
-    //
-    // This function is re-entrant
-    //
-    if (ThreadInitializeIndex == OS_INVALID_TLS_INDEX) {
-        assert(0 && "InitThread(): Process hasn't been initalised.");
-        return false;
-    }
-
-    if (OS_GetTLSValue(ThreadInitializeIndex) != 0)
-        return true;
-
-    if (! OS_SetTLSValue(ThreadInitializeIndex, (void *)1)) {
-        assert(0 && "InitThread(): Unable to set init flag.");
-        return false;
-    }
-
-    glslang::SetThreadPoolAllocator(nullptr);
-
-    return true;
-}
-
-// Not necessary to call this: InitThread() is reentrant, and the need
-// to do per thread tear down has been removed.
-//
-// This is kept, with memory management removed, to satisfy any exiting
-// calls to it that rely on it.
-bool DetachThread()
-{
-    bool success = true;
-
-    if (ThreadInitializeIndex == OS_INVALID_TLS_INDEX)
-        return true;
-
-    //
-    // Function is re-entrant and this thread may not have been initialized.
-    //
-    if (OS_GetTLSValue(ThreadInitializeIndex) != 0) {
-        if (!OS_SetTLSValue(ThreadInitializeIndex, (void *)0)) {
-            assert(0 && "DetachThread(): Unable to clear init flag.");
-            success = false;
-        }
-    }
-
-    return success;
-}
-
-// Not necessary to call this: InitProcess() is reentrant.
-//
-// This is kept, with memory management removed, to satisfy any exiting
-// calls to it that rely on it.
-//
-// Users of glslang should call shFinalize() or glslang::FinalizeProcess() for
-// process-scoped memory tear down.
-bool DetachProcess()
-{
-    bool success = true;
-
-    if (ThreadInitializeIndex == OS_INVALID_TLS_INDEX)
-        return true;
-
-    success = DetachThread();
-
-    OS_FreeTLSIndex(ThreadInitializeIndex);
-    ThreadInitializeIndex = OS_INVALID_TLS_INDEX;
-
-    return success;
-}
-
 } // end namespace glslang
diff --git a/OGLCompilersDLL/InitializeDll.h b/OGLCompilersDLL/InitializeDll.h
index 661cee4..b18e2ab 100644
--- a/OGLCompilersDLL/InitializeDll.h
+++ b/OGLCompilersDLL/InitializeDll.h
@@ -38,10 +38,10 @@
 
 namespace glslang {
 
-bool InitProcess();
-bool InitThread();
-bool DetachThread();  // not called from standalone, perhaps other tools rely on parts of it
-bool DetachProcess(); // not called from standalone, perhaps other tools rely on parts of it
+inline bool InitProcess()   { return true; } // DEPRECATED
+inline bool InitThread()    { return true; } // DEPRECATED
+inline bool DetachThread()  { return true; } // DEPRECATED
+inline bool DetachProcess() { return true; } // DEPRECATED
 
 } // end namespace glslang
 
diff --git a/README-spirv-remap.txt b/README-spirv-remap.txt
index 3e5288a..f3efee8 100644
--- a/README-spirv-remap.txt
+++ b/README-spirv-remap.txt
@@ -112,7 +112,7 @@
 
 BUILDING
 --------------------------------------------------------------------------------
-The standalone remapper is built along side glslangValidator through its
+The standalone remapper is built along side glslang through its
 normal build process.
 
 
diff --git a/README.md b/README.md
index 5e642e6..ea1e867 100644
--- a/README.md
+++ b/README.md
@@ -1,26 +1,19 @@
 # News
 
-1. Visual Studio 2013 is no longer supported
+1. [As discussed in #3107](https://github.com/KhronosGroup/glslang/issues/3107), the default branch of this repository is now 'main'. This change should be transparent to repository users, since github rewrites many references to the old 'master' branch to 'main'. However, if you have a checked-out local clone, you may wish to take the following steps as recommended by github:
 
-   [As scheduled](https://github.com/KhronosGroup/glslang/blob/9eef54b2513ca6b40b47b07d24f453848b65c0df/README.md#planned-deprecationsremovals),
-Microsoft Visual Studio 2013 is no longer officially supported. \
-   Please upgrade to at least Visual Studio 2015.
+```sh
+git branch -m master main
+git fetch origin
+git branch -u origin/main main
+git remote set-head origin -a
+```
 
-2. The versioning scheme is being improved, and you might notice some differences.  This is currently WIP, but will be coming soon.  See, for example, PR #2277.
+2. C++17 (all platforms) and Visual Studio 2019 (Windows) are now required. This change was driven by the external dependency on SPIRV-Tools.
 
-3. If you get a new **compilation error due to a missing header**, it might be caused by this planned removal:
-
-**SPIRV Folder, 1-May, 2020.** Glslang, when installed through CMake,
-will install a `SPIRV` folder into `${CMAKE_INSTALL_INCLUDEDIR}`.
-This `SPIRV` folder is being moved to `glslang/SPIRV`.
-During the transition the `SPIRV` folder will be installed into both locations.
-The old install of `SPIRV/` will be removed as a CMake install target no sooner than May 1, 2020.
-See issue #1964.
-
-If people are only using this location to get spirv.hpp, I recommend they get that from [SPIRV-Headers](https://github.com/KhronosGroup/SPIRV-Headers) instead.
-
-[![appveyor status](https://ci.appveyor.com/api/projects/status/q6fi9cb0qnhkla68/branch/master?svg=true)](https://ci.appveyor.com/project/Khronoswebmaster/glslang/branch/master)
+![Continuous Integration](https://github.com/KhronosGroup/glslang/actions/workflows/continuous_integration.yml/badge.svg)
 ![Continuous Deployment](https://github.com/KhronosGroup/glslang/actions/workflows/continuous_deployment.yml/badge.svg)
+[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/KhronosGroup/glslang/badge)](https://securityscorecards.dev/viewer/?uri=github.com/KhronosGroup/glslang)
 
 # Glslang Components and Status
 
@@ -55,7 +48,7 @@
 
 ### Standalone Wrapper
 
-`glslangValidator` is command-line tool for accessing the functionality above.
+`glslang` is command-line tool for accessing the functionality above.
 
 Status: Complete.
 
@@ -73,7 +66,7 @@
 
 ## Execution of Standalone Wrapper
 
-To use the standalone binary form, execute `glslangValidator`, and it will print
+To use the standalone binary form, execute `glslang`, and it will print
 a usage statement.  Basic operation is to give it a file containing a shader,
 and it will print out warnings/errors and optionally an AST.
 
@@ -99,15 +92,15 @@
 ## Building (CMake)
 
 Instead of building manually, you can also download the binaries for your
-platform directly from the [master-tot release][master-tot-release] on GitHub.
+platform directly from the [main-tot release][main-tot-release] on GitHub.
 Those binaries are automatically uploaded by the buildbots after successful
-testing and they always reflect the current top of the tree of the master
+testing and they always reflect the current top of the tree of the main
 branch.
 
 ### Dependencies
 
-* A C++11 compiler.
-  (For MSVS: use 2015 or later.)
+* A C++17 compiler.
+  (For MSVS: use 2019 or later.)
 * [CMake][cmake]: for generating compilation targets.
 * make: _Linux_, ninja is an alternative, if configured.
 * [Python 3.x][python]: for executing SPIRV-Tools scripts. (Optional if not using SPIRV-Tools and the 'External' subdirectory does not exist.)
@@ -242,16 +235,13 @@
 The command to rebuild is:
 
 ```bash
-m4 -P MachineIndependent/glslang.m4 > MachineIndependent/glslang.y
 bison --defines=MachineIndependent/glslang_tab.cpp.h
       -t MachineIndependent/glslang.y
       -o MachineIndependent/glslang_tab.cpp
 ```
 
-The above commands are also available in the bash script in `updateGrammar`,
+The above command is also available in the bash script in `updateGrammar`,
 when executed from the glslang subdirectory of the glslang repository.
-With no arguments it builds the full grammar, and with a "web" argument,
-the web grammar subset (see more about the web subset in the next section).
 
 ### Building to WASM for the Web and Node
 ### Building a standalone JS/WASM library for the Web and Node
@@ -261,15 +251,9 @@
   Bash-like environments:
   + [Instructions located here](https://emscripten.org/docs/getting_started/downloads.html#sdk-download-and-install)
 * Wrap cmake call: `emcmake cmake`
-* Set `-DBUILD_TESTING=OFF -DENABLE_OPT=OFF -DINSTALL_GTEST=OFF`.
+* Set `-DBUILD_TESTING=OFF -DENABLE_OPT=OFF`.
 * Set `-DENABLE_HLSL=OFF` if HLSL is not needed.
 * For a standalone JS/WASM library, turn on `-DENABLE_GLSLANG_JS=ON`.
-* For building a minimum-size web subset of core glslang:
-  + turn on `-DENABLE_GLSLANG_WEBMIN=ON` (disables HLSL)
-  + execute `updateGrammar web` from the glslang subdirectory
-    (or if using your own scripts, `m4` needs a `-DGLSLANG_WEB` argument)
-  + optionally, for GLSL compilation error messages, turn on
-    `-DENABLE_GLSLANG_WEBMIN_DEVEL=ON`
 * To get a fully minimized build, make sure to use `brotli` to compress the .js
   and .wasm files
 
@@ -277,7 +261,7 @@
 
 ```sh
 emcmake cmake -DCMAKE_BUILD_TYPE=Release -DENABLE_GLSLANG_JS=ON \
-    -DENABLE_HLSL=OFF -DBUILD_TESTING=OFF -DENABLE_OPT=OFF -DINSTALL_GTEST=OFF ..
+    -DENABLE_HLSL=OFF -DBUILD_TESTING=OFF -DENABLE_OPT=OFF ..
 ```
 
 ## Building glslang - Using vcpkg
@@ -433,9 +417,18 @@
 
 This interface is located `glslang_c_interface.h` and exposes functionality similar to the C++ interface. The following snippet is a complete example showing how to compile GLSL into SPIR-V 1.5 for Vulkan 1.2.
 
-```cxx
-std::vector<uint32_t> compileShaderToSPIRV_Vulkan(glslang_stage_t stage, const char* shaderSource, const char* fileName)
-{
+```c
+#include <glslang/Include/glslang_c_interface.h>
+
+// Required for use of glslang_default_resource
+#include <glslang/Public/resource_limits_c.h>
+
+typedef struct SpirVBinary {
+    uint32_t *words; // SPIR-V words
+    int size; // number of words in SPIR-V binary
+} SpirVBinary;
+
+SpirVBinary compileShaderToSPIRV_Vulkan(glslang_stage_t stage, const char* shaderSource, const char* fileName) {
     const glslang_input_t input = {
         .language = GLSLANG_SOURCE_GLSL,
         .stage = stage,
@@ -449,18 +442,22 @@
         .force_default_version_and_profile = false,
         .forward_compatible = false,
         .messages = GLSLANG_MSG_DEFAULT_BIT,
-        .resource = reinterpret_cast<const glslang_resource_t*>(&glslang::DefaultTBuiltInResource),
+        .resource = glslang_default_resource(),
     };
 
     glslang_shader_t* shader = glslang_shader_create(&input);
 
+    SpirVBinary bin = {
+        .words = NULL,
+        .size = 0,
+    };
     if (!glslang_shader_preprocess(shader, &input))	{
         printf("GLSL preprocessing failed %s\n", fileName);
         printf("%s\n", glslang_shader_get_info_log(shader));
         printf("%s\n", glslang_shader_get_info_debug_log(shader));
         printf("%s\n", input.code);
         glslang_shader_delete(shader);
-        return std::vector<uint32_t>();
+        return bin;
     }
 
     if (!glslang_shader_parse(shader, &input)) {
@@ -469,7 +466,7 @@
         printf("%s\n", glslang_shader_get_info_debug_log(shader));
         printf("%s\n", glslang_shader_get_preprocessed_code(shader));
         glslang_shader_delete(shader);
-        return std::vector<uint32_t>();
+        return bin;
     }
 
     glslang_program_t* program = glslang_program_create();
@@ -481,13 +478,14 @@
         printf("%s\n", glslang_program_get_info_debug_log(program));
         glslang_program_delete(program);
         glslang_shader_delete(shader);
-        return std::vector<uint32_t>();
+        return bin;
     }
 
     glslang_program_SPIRV_generate(program, stage);
 
-    std::vector<uint32_t> outShaderModule(glslang_program_SPIRV_get_size(program));
-    glslang_program_SPIRV_get(program, outShaderModule.data());
+    bin.size = glslang_program_SPIRV_get_size(program);
+    bin.words = malloc(bin.size * sizeof(uint32_t));
+    glslang_program_SPIRV_get(program, bin.words);
 
     const char* spirv_messages = glslang_program_SPIRV_get_messages(program);
     if (spirv_messages)
@@ -496,7 +494,7 @@
     glslang_program_delete(program);
     glslang_shader_delete(shader);
 
-    return outShaderModule;
+    return bin;
 }
 ```
 
@@ -555,4 +553,4 @@
 [bison]: https://www.gnu.org/software/bison/
 [googletest]: https://github.com/google/googletest
 [bison-gnu-win32]: http://gnuwin32.sourceforge.net/packages/bison.htm
-[master-tot-release]: https://github.com/KhronosGroup/glslang/releases/tag/master-tot
+[main-tot-release]: https://github.com/KhronosGroup/glslang/releases/tag/main-tot
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 0000000..ffa39bf
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,6 @@
+# Security Policy
+
+To report a security issue, please disclose it at [security advisory](https://github.com/KhronosGroup/glslang/security/advisories/new).
+
+This project is maintained by a team of volunteers on a reasonable-effort basis. As
+such, please give us at least 90 days to work on a fix before public exposure.
diff --git a/SPIRV/CInterface/spirv_c_interface.cpp b/SPIRV/CInterface/spirv_c_interface.cpp
index d56ad46..5e7316e 100644
--- a/SPIRV/CInterface/spirv_c_interface.cpp
+++ b/SPIRV/CInterface/spirv_c_interface.cpp
@@ -92,6 +92,7 @@
     spv_options.optimize_size = false;
     spv_options.disassemble = false;
     spv_options.validate = true;
+    spv_options.compile_only = false;
 
     glslang_program_SPIRV_generate_with_options(program, stage, &spv_options);
 }
diff --git a/SPIRV/CMakeLists.txt b/SPIRV/CMakeLists.txt
index 2408e4c..a80e74e 100644
--- a/SPIRV/CMakeLists.txt
+++ b/SPIRV/CMakeLists.txt
@@ -62,6 +62,7 @@
     disassemble.h
     GLSL.ext.AMD.h
     GLSL.ext.NV.h
+    GLSL.ext.ARM.h
     NonSemanticDebugPrintf.h
     NonSemanticShaderDebugInfo100.h)
 
@@ -70,8 +71,11 @@
     doc.h)
 
 add_library(SPIRV ${LIB_TYPE} ${SOURCES} ${HEADERS})
-set_property(TARGET SPIRV PROPERTY FOLDER glslang)
-set_property(TARGET SPIRV PROPERTY POSITION_INDEPENDENT_CODE ON)
+set_target_properties(SPIRV PROPERTIES
+    FOLDER glslang
+    POSITION_INDEPENDENT_CODE ON
+    VERSION   "${GLSLANG_VERSION}"
+    SOVERSION "${GLSLANG_VERSION_MAJOR}")
 target_include_directories(SPIRV PUBLIC
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>
     $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
@@ -80,8 +84,11 @@
 
 if (ENABLE_SPVREMAPPER)
     add_library(SPVRemapper ${LIB_TYPE} ${SPVREMAP_SOURCES} ${SPVREMAP_HEADERS})
-    set_property(TARGET SPVRemapper PROPERTY FOLDER glslang)
-    set_property(TARGET SPVRemapper PROPERTY POSITION_INDEPENDENT_CODE ON)
+    set_target_properties(SPVRemapper PROPERTIES
+        FOLDER glslang
+        POSITION_INDEPENDENT_CODE ON
+        VERSION   "${GLSLANG_VERSION}"
+        SOVERSION "${GLSLANG_VERSION_MAJOR}")
 endif()
 
 if(WIN32 AND BUILD_SHARED_LIBS)
@@ -122,7 +129,7 @@
             message(WARNING \"Using `SPVRemapperTargets.cmake` is deprecated: use `find_package(glslang)` to find glslang CMake targets.\")
 
             if (NOT TARGET glslang::SPVRemapper)
-                include(\"\${CMAKE_CURRENT_LIST_DIR}/../../${CMAKE_INSTALL_LIBDIR}/${PROJECT_NAME}/glslang-targets.cmake\")
+                include(\"${CMAKE_INSTALL_FULL_LIBDIR}/cmake/${PROJECT_NAME}/glslang-targets.cmake\")
             endif()
 
             add_library(SPVRemapper ALIAS glslang::SPVRemapper)
@@ -134,7 +141,7 @@
         message(WARNING \"Using `SPIRVTargets.cmake` is deprecated: use `find_package(glslang)` to find glslang CMake targets.\")
 
         if (NOT TARGET glslang::SPIRV)
-            include(\"\${CMAKE_CURRENT_LIST_DIR}/../../${CMAKE_INSTALL_LIBDIR}/${PROJECT_NAME}/glslang-targets.cmake\")
+            include(\"${CMAKE_INSTALL_FULL_LIBDIR}/cmake/${PROJECT_NAME}/glslang-targets.cmake\")
         endif()
 
         add_library(SPIRV ALIAS glslang::SPIRV)
diff --git a/SPIRV/GLSL.ext.ARM.h b/SPIRV/GLSL.ext.ARM.h
new file mode 100644
index 0000000..14425be
--- /dev/null
+++ b/SPIRV/GLSL.ext.ARM.h
@@ -0,0 +1,35 @@
+/*
+** Copyright (c) 2022 ARM Limited
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and/or associated documentation files (the "Materials"),
+** to deal in the Materials without restriction, including without limitation
+** the rights to use, copy, modify, merge, publish, distribute, sublicense,
+** and/or sell copies of the Materials, and to permit persons to whom the
+** Materials are furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Materials.
+**
+** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
+**
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+** IN THE MATERIALS.
+*/
+
+#ifndef GLSLextARM_H
+#define GLSLextARM_H
+
+static const int GLSLextARMVersion = 100;
+static const int GLSLextARMRevision = 1;
+
+static const char * const E_SPV_ARM_core_builtins = "SPV_ARM_core_builtins";
+
+#endif  // #ifndef GLSLextARM_H
diff --git a/SPIRV/GLSL.ext.EXT.h b/SPIRV/GLSL.ext.EXT.h
index a247b4c..caab279 100644
--- a/SPIRV/GLSL.ext.EXT.h
+++ b/SPIRV/GLSL.ext.EXT.h
@@ -39,6 +39,7 @@
 static const char* const E_SPV_EXT_shader_atomic_float16_add = "SPV_EXT_shader_atomic_float16_add";
 static const char* const E_SPV_EXT_shader_atomic_float_min_max = "SPV_EXT_shader_atomic_float_min_max";
 static const char* const E_SPV_EXT_shader_image_int64 = "SPV_EXT_shader_image_int64";
+static const char* const E_SPV_EXT_shader_tile_image = "SPV_EXT_shader_tile_image";
 static const char* const E_SPV_EXT_mesh_shader = "SPV_EXT_mesh_shader";
 
 #endif  // #ifndef GLSLextEXT_H
diff --git a/SPIRV/GLSL.ext.KHR.h b/SPIRV/GLSL.ext.KHR.h
index d5c670f..121defa 100644
--- a/SPIRV/GLSL.ext.KHR.h
+++ b/SPIRV/GLSL.ext.KHR.h
@@ -54,5 +54,7 @@
 static const char* const E_SPV_KHR_subgroup_uniform_control_flow = "SPV_KHR_subgroup_uniform_control_flow";
 static const char* const E_SPV_KHR_fragment_shader_barycentric = "SPV_KHR_fragment_shader_barycentric";
 static const char* const E_SPV_AMD_shader_early_and_late_fragment_tests = "SPV_AMD_shader_early_and_late_fragment_tests";
+static const char* const E_SPV_KHR_ray_tracing_position_fetch   = "SPV_KHR_ray_tracing_position_fetch";
+static const char* const E_SPV_KHR_cooperative_matrix           = "SPV_KHR_cooperative_matrix";
 
 #endif  // #ifndef GLSLextKHR_H
diff --git a/SPIRV/GLSL.ext.NV.h b/SPIRV/GLSL.ext.NV.h
index 93c98bf..9889bc9 100644
--- a/SPIRV/GLSL.ext.NV.h
+++ b/SPIRV/GLSL.ext.NV.h
@@ -81,4 +81,10 @@
 //SPV_NV_shader_sm_builtins
 const char* const E_SPV_NV_shader_sm_builtins = "SPV_NV_shader_sm_builtins";
 
+//SPV_NV_shader_execution_reorder
+const char* const E_SPV_NV_shader_invocation_reorder = "SPV_NV_shader_invocation_reorder";
+
+//SPV_NV_displacement_micromap
+const char* const E_SPV_NV_displacement_micromap = "SPV_NV_displacement_micromap";
+
 #endif  // #ifndef GLSLextNV_H
diff --git a/SPIRV/GLSL.ext.QCOM.h b/SPIRV/GLSL.ext.QCOM.h
new file mode 100644
index 0000000..f13bb69
--- /dev/null
+++ b/SPIRV/GLSL.ext.QCOM.h
@@ -0,0 +1,41 @@
+/*
+** Copyright (c) 2021 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and/or associated documentation files (the "Materials"),
+** to deal in the Materials without restriction, including without limitation
+** the rights to use, copy, modify, merge, publish, distribute, sublicense,
+** and/or sell copies of the Materials, and to permit persons to whom the
+** Materials are furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Materials.
+**
+** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
+**
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+** IN THE MATERIALS.
+*/
+
+#ifndef GLSLextQCOM_H
+#define GLSLextQCOM_H
+
+enum BuiltIn;
+enum Decoration;
+enum Op;
+enum Capability;
+
+static const int GLSLextQCOMVersion = 100;
+static const int GLSLextQCOMRevision = 1;
+
+//SPV_QCOM_image_processing
+const char* const E_SPV_QCOM_image_processing = "SPV_QCOM_image_processing";
+
+#endif  // #ifndef GLSLextQCOM_H
diff --git a/SPIRV/GLSL.std.450.h b/SPIRV/GLSL.std.450.h
index df31092..86d3da8 100644
--- a/SPIRV/GLSL.std.450.h
+++ b/SPIRV/GLSL.std.450.h
@@ -13,7 +13,7 @@
 **
 ** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
 ** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
-** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
+** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
 **
 ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 ** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
diff --git a/SPIRV/GlslangToSpv.cpp b/SPIRV/GlslangToSpv.cpp
old mode 100644
new mode 100755
index ccb4602..576c680
--- a/SPIRV/GlslangToSpv.cpp
+++ b/SPIRV/GlslangToSpv.cpp
@@ -49,6 +49,8 @@
     #include "GLSL.ext.EXT.h"
     #include "GLSL.ext.AMD.h"
     #include "GLSL.ext.NV.h"
+    #include "GLSL.ext.ARM.h"
+    #include "GLSL.ext.QCOM.h"
     #include "NonSemanticDebugPrintf.h"
 }
 
@@ -94,26 +96,18 @@
     public:
         OpDecorations(spv::Decoration precision, spv::Decoration noContraction, spv::Decoration nonUniform) :
             precision(precision)
-#ifndef GLSLANG_WEB
             ,
             noContraction(noContraction),
             nonUniform(nonUniform)
-#endif
         { }
 
     spv::Decoration precision;
 
-#ifdef GLSLANG_WEB
-        void addNoContraction(spv::Builder&, spv::Id) const { }
-        void addNonUniform(spv::Builder&, spv::Id) const { }
-#else
         void addNoContraction(spv::Builder& builder, spv::Id t) { builder.addDecoration(t, noContraction); }
         void addNonUniform(spv::Builder& builder, spv::Id t)  { builder.addDecoration(t, nonUniform); }
     protected:
         spv::Decoration noContraction;
         spv::Decoration nonUniform;
-#endif
-
 };
 
 } // namespace
@@ -139,7 +133,7 @@
     bool visitLoop(glslang::TVisit, glslang::TIntermLoop*);
     bool visitBranch(glslang::TVisit visit, glslang::TIntermBranch*);
 
-    void finishSpv();
+    void finishSpv(bool compileOnly);
     void dumpSpv(std::vector<unsigned int>& out);
 
 protected:
@@ -173,9 +167,10 @@
     bool filterMember(const glslang::TType& member);
     spv::Id convertGlslangStructToSpvType(const glslang::TType&, const glslang::TTypeList* glslangStruct,
                                           glslang::TLayoutPacking, const glslang::TQualifier&);
+    spv::LinkageType convertGlslangLinkageToSpv(glslang::TLinkType glslangLinkType);
     void decorateStructType(const glslang::TType&, const glslang::TTypeList* glslangStruct, glslang::TLayoutPacking,
-                            const glslang::TQualifier&, spv::Id);
-    spv::Id makeArraySizeId(const glslang::TArraySizes&, int dim);
+                            const glslang::TQualifier&, spv::Id, const std::vector<spv::Id>& spvMembers);
+    spv::Id makeArraySizeId(const glslang::TArraySizes&, int dim, bool allowZero = false);
     spv::Id accessChainLoad(const glslang::TType& type);
     void    accessChainStore(const glslang::TType& type, spv::Id rvalue);
     void multiTypeStore(const glslang::TType&, spv::Id rValue);
@@ -211,7 +206,7 @@
                                        glslang::TBasicType typeProxy);
     spv::Id createConversion(glslang::TOperator op, OpDecorations&, spv::Id destTypeId, spv::Id operand,
                              glslang::TBasicType typeProxy);
-    spv::Id createIntWidthConversion(glslang::TOperator op, spv::Id operand, int vectorSize);
+    spv::Id createIntWidthConversion(glslang::TOperator op, spv::Id operand, int vectorSize, spv::Id destType);
     spv::Id makeSmearedConstant(spv::Id constant, int vectorSize);
     spv::Id createAtomicOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId,
         std::vector<spv::Id>& operands, glslang::TBasicType typeProxy,
@@ -227,6 +222,7 @@
     spv::Id createNoArgOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId);
     spv::Id getSymbolId(const glslang::TIntermSymbol* node);
     void addMeshNVDecoration(spv::Id id, int member, const glslang::TQualifier & qualifier);
+    void addImageProcessingQCOMDecoration(spv::Id id, spv::Decoration decor);
     spv::Id createSpvConstant(const glslang::TIntermTyped&);
     spv::Id createSpvConstantFromConstUnionArray(const glslang::TType& type, const glslang::TConstUnionArray&,
         int& nextConst, bool specConstant);
@@ -277,12 +273,10 @@
     // requiring local translation to and from SPIR-V type on every access.
     // Maps <builtin-variable-id -> AST-required-type-id>
     std::unordered_map<spv::Id, spv::Id> forceType;
-
-    // Used later for generating OpTraceKHR/OpExecuteCallableKHR
-    std::unordered_map<unsigned int, glslang::TIntermSymbol *> locationToSymbol[2];
-
     // Used by Task shader while generating opearnds for OpEmitMeshTasksEXT
     spv::Id taskPayloadID;
+    // Used later for generating OpTraceKHR/OpExecuteCallableKHR/OpHitObjectRecordHit*/OpHitObjectGetShaderBindingTableData
+    std::unordered_map<unsigned int, glslang::TIntermSymbol *> locationToSymbol[4];
 };
 
 //
@@ -292,12 +286,6 @@
 // Translate glslang profile to SPIR-V source language.
 spv::SourceLanguage TranslateSourceLanguage(glslang::EShSource source, EProfile profile)
 {
-#ifdef GLSLANG_WEB
-    return spv::SourceLanguageESSL;
-#elif defined(GLSLANG_ANGLE)
-    return spv::SourceLanguageGLSL;
-#endif
-
     switch (source) {
     case glslang::EShSourceGlsl:
         switch (profile) {
@@ -324,7 +312,6 @@
     case EShLangVertex:           return spv::ExecutionModelVertex;
     case EShLangFragment:         return spv::ExecutionModelFragment;
     case EShLangCompute:          return spv::ExecutionModelGLCompute;
-#ifndef GLSLANG_WEB
     case EShLangTessControl:      return spv::ExecutionModelTessellationControl;
     case EShLangTessEvaluation:   return spv::ExecutionModelTessellationEvaluation;
     case EShLangGeometry:         return spv::ExecutionModelGeometry;
@@ -336,7 +323,6 @@
     case EShLangCallable:         return spv::ExecutionModelCallableKHR;
     case EShLangTask:             return (isMeshShaderEXT)? spv::ExecutionModelTaskEXT : spv::ExecutionModelTaskNV;
     case EShLangMesh:             return (isMeshShaderEXT)? spv::ExecutionModelMeshEXT: spv::ExecutionModelMeshNV;
-#endif
     default:
         assert(0);
         return spv::ExecutionModelFragment;
@@ -354,6 +340,7 @@
     case glslang::EsdRect:    return spv::DimRect;
     case glslang::EsdBuffer:  return spv::DimBuffer;
     case glslang::EsdSubpass: return spv::DimSubpassData;
+    case glslang::EsdAttachmentEXT: return spv::DimTileImageDataEXT;
     default:
         assert(0);
         return spv::Dim2D;
@@ -378,26 +365,23 @@
 }
 
 // Translate glslang type to SPIR-V block decorations.
-spv::Decoration TranslateBlockDecoration(const glslang::TType& type, bool useStorageBuffer)
+spv::Decoration TranslateBlockDecoration(const glslang::TStorageQualifier storage, bool useStorageBuffer)
 {
-    if (type.getBasicType() == glslang::EbtBlock) {
-        switch (type.getQualifier().storage) {
-        case glslang::EvqUniform:      return spv::DecorationBlock;
-        case glslang::EvqBuffer:       return useStorageBuffer ? spv::DecorationBlock : spv::DecorationBufferBlock;
-        case glslang::EvqVaryingIn:    return spv::DecorationBlock;
-        case glslang::EvqVaryingOut:   return spv::DecorationBlock;
-        case glslang::EvqShared:       return spv::DecorationBlock;
-#ifndef GLSLANG_WEB
-        case glslang::EvqPayload:      return spv::DecorationBlock;
-        case glslang::EvqPayloadIn:    return spv::DecorationBlock;
-        case glslang::EvqHitAttr:      return spv::DecorationBlock;
-        case glslang::EvqCallableData:   return spv::DecorationBlock;
-        case glslang::EvqCallableDataIn: return spv::DecorationBlock;
-#endif
-        default:
-            assert(0);
-            break;
-        }
+    switch (storage) {
+    case glslang::EvqUniform:      return spv::DecorationBlock;
+    case glslang::EvqBuffer:       return useStorageBuffer ? spv::DecorationBlock : spv::DecorationBufferBlock;
+    case glslang::EvqVaryingIn:    return spv::DecorationBlock;
+    case glslang::EvqVaryingOut:   return spv::DecorationBlock;
+    case glslang::EvqShared:       return spv::DecorationBlock;
+    case glslang::EvqPayload:      return spv::DecorationBlock;
+    case glslang::EvqPayloadIn:    return spv::DecorationBlock;
+    case glslang::EvqHitAttr:      return spv::DecorationBlock;
+    case glslang::EvqCallableData:   return spv::DecorationBlock;
+    case glslang::EvqCallableDataIn: return spv::DecorationBlock;
+    case glslang::EvqHitObjectAttrNV: return spv::DecorationBlock;
+    default:
+        assert(0);
+        break;
     }
 
     return spv::DecorationMax;
@@ -464,14 +448,13 @@
                     assert(type.getQualifier().layoutPacking == glslang::ElpNone);
                 }
                 return spv::DecorationMax;
-#ifndef GLSLANG_WEB
             case glslang::EvqPayload:
             case glslang::EvqPayloadIn:
             case glslang::EvqHitAttr:
             case glslang::EvqCallableData:
             case glslang::EvqCallableDataIn:
+            case glslang::EvqHitObjectAttrNV:
                 return spv::DecorationMax;
-#endif
             default:
                 assert(0);
                 return spv::DecorationMax;
@@ -507,14 +490,12 @@
 {
     if (qualifier.centroid)
         return spv::DecorationCentroid;
-#ifndef GLSLANG_WEB
     else if (qualifier.patch)
         return spv::DecorationPatch;
     else if (qualifier.sample) {
         builder.addCapability(spv::CapabilitySampleRateShading);
         return spv::DecorationSample;
     }
-#endif
 
     return spv::DecorationMax;
 }
@@ -531,24 +512,20 @@
 // If glslang type is noContraction, return SPIR-V NoContraction decoration.
 spv::Decoration TranslateNoContractionDecoration(const glslang::TQualifier& qualifier)
 {
-#ifndef GLSLANG_WEB
     if (qualifier.isNoContraction())
         return spv::DecorationNoContraction;
     else
-#endif
         return spv::DecorationMax;
 }
 
 // If glslang type is nonUniform, return SPIR-V NonUniform decoration.
 spv::Decoration TGlslangToSpvTraverser::TranslateNonUniformDecoration(const glslang::TQualifier& qualifier)
 {
-#ifndef GLSLANG_WEB
     if (qualifier.isNonUniform()) {
         builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5);
         builder.addCapability(spv::CapabilityShaderNonUniformEXT);
         return spv::DecorationNonUniformEXT;
     } else
-#endif
         return spv::DecorationMax;
 }
 
@@ -556,13 +533,11 @@
 spv::Decoration TGlslangToSpvTraverser::TranslateNonUniformDecoration(
     const spv::Builder::AccessChain::CoherentFlags& coherentFlags)
 {
-#ifndef GLSLANG_WEB
     if (coherentFlags.isNonUniform()) {
         builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5);
         builder.addCapability(spv::CapabilityShaderNonUniformEXT);
         return spv::DecorationNonUniformEXT;
     } else
-#endif
         return spv::DecorationMax;
 }
 
@@ -571,7 +546,6 @@
 {
     spv::MemoryAccessMask mask = spv::MemoryAccessMaskNone;
 
-#ifndef GLSLANG_WEB
     if (!glslangIntermediate->usingVulkanMemoryModel() || coherentFlags.isImage)
         return mask;
 
@@ -589,7 +563,6 @@
     if (mask != spv::MemoryAccessMaskNone) {
         builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
     }
-#endif
 
     return mask;
 }
@@ -599,7 +572,6 @@
 {
     spv::ImageOperandsMask mask = spv::ImageOperandsMaskNone;
 
-#ifndef GLSLANG_WEB
     if (!glslangIntermediate->usingVulkanMemoryModel())
         return mask;
 
@@ -617,7 +589,6 @@
     if (mask != spv::ImageOperandsMaskNone) {
         builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
     }
-#endif
 
     return mask;
 }
@@ -625,7 +596,6 @@
 spv::Builder::AccessChain::CoherentFlags TGlslangToSpvTraverser::TranslateCoherent(const glslang::TType& type)
 {
     spv::Builder::AccessChain::CoherentFlags flags = {};
-#ifndef GLSLANG_WEB
     flags.coherent = type.getQualifier().coherent;
     flags.devicecoherent = type.getQualifier().devicecoherent;
     flags.queuefamilycoherent = type.getQualifier().queuefamilycoherent;
@@ -640,7 +610,6 @@
                        flags.anyCoherent() ||
                        flags.volatil;
     flags.isImage = type.getBasicType() == glslang::EbtSampler;
-#endif
     flags.nonUniform = type.getQualifier().nonUniform;
     return flags;
 }
@@ -650,7 +619,6 @@
 {
     spv::Scope scope = spv::ScopeMax;
 
-#ifndef GLSLANG_WEB
     if (coherentFlags.volatil || coherentFlags.coherent) {
         // coherent defaults to Device scope in the old model, QueueFamilyKHR scope in the new model
         scope = glslangIntermediate->usingVulkanMemoryModel() ? spv::ScopeQueueFamilyKHR : spv::ScopeDevice;
@@ -668,7 +636,6 @@
     if (glslangIntermediate->usingVulkanMemoryModel() && scope == spv::ScopeDevice) {
         builder.addCapability(spv::CapabilityVulkanMemoryModelDeviceScopeKHR);
     }
-#endif
 
     return scope;
 }
@@ -683,7 +650,6 @@
 {
     switch (builtIn) {
     case glslang::EbvPointSize:
-#ifndef GLSLANG_WEB
         // Defer adding the capability until the built-in is actually used.
         if (! memberDeclaration) {
             switch (glslangIntermediate->getStage()) {
@@ -698,7 +664,6 @@
                 break;
             }
         }
-#endif
         return spv::BuiltInPointSize;
 
     case glslang::EbvPosition:             return spv::BuiltInPosition;
@@ -719,7 +684,6 @@
     case glslang::EbvLocalInvocationIndex: return spv::BuiltInLocalInvocationIndex;
     case glslang::EbvGlobalInvocationId:   return spv::BuiltInGlobalInvocationId;
 
-#ifndef GLSLANG_WEB
     // These *Distance capabilities logically belong here, but if the member is declared and
     // then never used, consumers of SPIR-V prefer the capability not be declared.
     // They are now generated when used, rather than here when declared.
@@ -1013,6 +977,8 @@
         return spv::BuiltInRayTmaxKHR;
     case glslang::EbvCullMask:
         return spv::BuiltInCullMaskKHR;
+    case glslang::EbvPositionFetch:
+        return spv::BuiltInHitTriangleVertexPositionsKHR;
     case glslang::EbvInstanceCustomIndex:
         return spv::BuiltInInstanceCustomIndexKHR;
     case glslang::EbvHitT:
@@ -1043,6 +1009,22 @@
         builder.addExtension(spv::E_SPV_NV_ray_tracing_motion_blur);
         builder.addCapability(spv::CapabilityRayTracingMotionBlurNV);
         return spv::BuiltInCurrentRayTimeNV;
+    case glslang::EbvMicroTrianglePositionNV:
+        builder.addCapability(spv::CapabilityRayTracingDisplacementMicromapNV);
+        builder.addExtension("SPV_NV_displacement_micromap");
+        return spv::BuiltInHitMicroTriangleVertexPositionsNV;
+    case glslang::EbvMicroTriangleBaryNV:
+        builder.addCapability(spv::CapabilityRayTracingDisplacementMicromapNV);
+        builder.addExtension("SPV_NV_displacement_micromap");
+        return spv::BuiltInHitMicroTriangleVertexBarycentricsNV;
+    case glslang::EbvHitKindFrontFacingMicroTriangleNV:
+        builder.addCapability(spv::CapabilityRayTracingDisplacementMicromapNV);
+        builder.addExtension("SPV_NV_displacement_micromap");
+        return spv::BuiltInHitKindFrontFacingMicroTriangleNV;
+    case glslang::EbvHitKindBackFacingMicroTriangleNV:
+        builder.addCapability(spv::CapabilityRayTracingDisplacementMicromapNV);
+        builder.addExtension("SPV_NV_displacement_micromap");
+        return spv::BuiltInHitKindBackFacingMicroTriangleNV;
 
     // barycentrics
     case glslang::EbvBaryCoordNV:
@@ -1108,7 +1090,28 @@
         builder.addExtension(spv::E_SPV_NV_shader_sm_builtins);
         builder.addCapability(spv::CapabilityShaderSMBuiltinsNV);
         return spv::BuiltInSMIDNV;
-#endif
+
+   // ARM builtins
+    case glslang::EbvCoreCountARM:
+        builder.addExtension(spv::E_SPV_ARM_core_builtins);
+        builder.addCapability(spv::CapabilityCoreBuiltinsARM);
+        return spv::BuiltInCoreCountARM;
+    case glslang::EbvCoreIDARM:
+        builder.addExtension(spv::E_SPV_ARM_core_builtins);
+        builder.addCapability(spv::CapabilityCoreBuiltinsARM);
+        return spv::BuiltInCoreIDARM;
+    case glslang::EbvCoreMaxIDARM:
+        builder.addExtension(spv::E_SPV_ARM_core_builtins);
+        builder.addCapability(spv::CapabilityCoreBuiltinsARM);
+        return spv::BuiltInCoreMaxIDARM;
+    case glslang::EbvWarpIDARM:
+        builder.addExtension(spv::E_SPV_ARM_core_builtins);
+        builder.addCapability(spv::CapabilityCoreBuiltinsARM);
+        return spv::BuiltInWarpIDARM;
+    case glslang::EbvWarpMaxIDARM:
+        builder.addExtension(spv::E_SPV_ARM_core_builtins);
+        builder.addCapability(spv::CapabilityCoreBuiltinsARM);
+        return spv::BuiltInWarpMaxIDARM;
 
     default:
         return spv::BuiltInMax;
@@ -1120,10 +1123,6 @@
 {
     assert(type.getBasicType() == glslang::EbtSampler);
 
-#ifdef GLSLANG_WEB
-    return spv::ImageFormatUnknown;
-#endif
-
     // Check for capabilities
     switch (type.getQualifier().getFormat()) {
     case glslang::ElfRg32f:
@@ -1278,24 +1277,27 @@
 // Translate glslang type to SPIR-V storage class.
 spv::StorageClass TGlslangToSpvTraverser::TranslateStorageClass(const glslang::TType& type)
 {
-    if (type.getBasicType() == glslang::EbtRayQuery)
+    if (type.getBasicType() == glslang::EbtRayQuery || type.getBasicType() == glslang::EbtHitObjectNV)
         return spv::StorageClassPrivate;
-#ifndef GLSLANG_WEB
     if (type.getQualifier().isSpirvByReference()) {
         if (type.getQualifier().isParamInput() || type.getQualifier().isParamOutput())
             return spv::StorageClassFunction;
     }
-#endif
     if (type.getQualifier().isPipeInput())
         return spv::StorageClassInput;
     if (type.getQualifier().isPipeOutput())
         return spv::StorageClassOutput;
+    if (type.getQualifier().storage == glslang::EvqTileImageEXT || type.isAttachmentEXT()) {
+        builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
+        builder.addCapability(spv::CapabilityTileImageColorReadAccessEXT);
+        return spv::StorageClassTileImageEXT;
+    }
 
     if (glslangIntermediate->getSource() != glslang::EShSourceHlsl ||
             type.getQualifier().storage == glslang::EvqUniform) {
         if (type.isAtomic())
             return spv::StorageClassAtomicCounter;
-        if (type.containsOpaque())
+        if (type.containsOpaque() && !glslangIntermediate->getBindlessMode())
             return spv::StorageClassUniformConstant;
     }
 
@@ -1328,15 +1330,14 @@
     case glslang::EvqConstReadOnly: return spv::StorageClassFunction;
     case glslang::EvqTemporary:     return spv::StorageClassFunction;
     case glslang::EvqShared:           return spv::StorageClassWorkgroup;
-#ifndef GLSLANG_WEB
     case glslang::EvqPayload:        return spv::StorageClassRayPayloadKHR;
     case glslang::EvqPayloadIn:      return spv::StorageClassIncomingRayPayloadKHR;
     case glslang::EvqHitAttr:        return spv::StorageClassHitAttributeKHR;
     case glslang::EvqCallableData:   return spv::StorageClassCallableDataKHR;
     case glslang::EvqCallableDataIn: return spv::StorageClassIncomingCallableDataKHR;
     case glslang::EvqtaskPayloadSharedEXT : return spv::StorageClassTaskPayloadWorkgroupEXT;
+    case glslang::EvqHitObjectAttrNV: return spv::StorageClassHitObjectAttributeNV;
     case glslang::EvqSpirvStorageClass: return static_cast<spv::StorageClass>(type.getQualifier().spirvStorageClass);
-#endif
     default:
         assert(0);
         break;
@@ -1397,7 +1398,6 @@
 void TGlslangToSpvTraverser::addIndirectionIndexCapabilities(const glslang::TType& baseType,
                                                              const glslang::TType& indexType)
 {
-#ifndef GLSLANG_WEB
     if (indexType.getQualifier().isNonUniform()) {
         // deal with an asserted non-uniform index
         // SPV_EXT_descriptor_indexing already added in TranslateNonUniformDecoration
@@ -1433,7 +1433,6 @@
             }
         }
     }
-#endif
 }
 
 // Return whether or not the given type is something that should be tied to a
@@ -1469,7 +1468,6 @@
         child.flat = true;
     if (parent.centroid)
         child.centroid = true;
-#ifndef GLSLANG_WEB
     if (parent.nopersp)
         child.nopersp = true;
     if (parent.explicitInterp)
@@ -1508,7 +1506,6 @@
         child.readonly = true;
     if (parent.writeonly)
         child.writeonly = true;
-#endif
     if (parent.nonUniform)
         child.nonUniform = true;
 }
@@ -1552,7 +1549,12 @@
     builder.setSource(TranslateSourceLanguage(glslangIntermediate->getSource(), glslangIntermediate->getProfile()),
                       glslangIntermediate->getVersion());
 
-    if (options.generateDebugInfo) {
+    if (options.emitNonSemanticShaderDebugSource)
+            this->options.emitNonSemanticShaderDebugInfo = true;
+    if (options.emitNonSemanticShaderDebugInfo)
+            this->options.generateDebugInfo = true;
+
+    if (this->options.generateDebugInfo) {
         builder.setEmitOpLines();
         builder.setSourceFile(glslangIntermediate->getSourceFile());
 
@@ -1579,8 +1581,8 @@
             builder.addInclude(iItr->first, iItr->second);
     }
 
-    builder.setEmitNonSemanticShaderDebugInfo(options.emitNonSemanticShaderDebugInfo);
-    builder.setEmitNonSemanticShaderDebugSource(options.emitNonSemanticShaderDebugSource);
+    builder.setEmitNonSemanticShaderDebugInfo(this->options.emitNonSemanticShaderDebugInfo);
+    builder.setEmitNonSemanticShaderDebugSource(this->options.emitNonSemanticShaderDebugSource);
 
     stdBuiltins = builder.import("GLSL.std.450");
 
@@ -1603,8 +1605,12 @@
         builder.addCapability(spv::CapabilityVariablePointers);
     }
 
-    shaderEntry = builder.makeEntryPoint(glslangIntermediate->getEntryPointName().c_str());
-    entryPoint = builder.addEntryPoint(executionModel, shaderEntry, glslangIntermediate->getEntryPointName().c_str());
+    // If not linking, there is no entry point
+    if (!options.compileOnly) {
+        shaderEntry = builder.makeEntryPoint(glslangIntermediate->getEntryPointName().c_str());
+        entryPoint =
+            builder.addEntryPoint(executionModel, shaderEntry, glslangIntermediate->getEntryPointName().c_str());
+    }
 
     // Add the source extensions
     const auto& sourceExtensions = glslangIntermediate->getRequestedExtensions();
@@ -1622,12 +1628,10 @@
         builder.addCapability(spv::CapabilityRayTraversalPrimitiveCullingKHR);
     }
 
-#ifndef GLSLANG_WEB
     if (glslangIntermediate->getSubgroupUniformControlFlow()) {
         builder.addExtension(spv::E_SPV_KHR_subgroup_uniform_control_flow);
         builder.addExecutionMode(shaderEntry, spv::ExecutionModeSubgroupUniformControlFlowKHR);
     }
-#endif
 
     unsigned int mode;
     switch (glslangIntermediate->getStage()) {
@@ -1660,14 +1664,30 @@
             builder.addExtension(spv::E_SPV_KHR_post_depth_coverage);
         }
 
+        if (glslangIntermediate->getNonCoherentColorAttachmentReadEXT()) {
+            builder.addCapability(spv::CapabilityTileImageColorReadAccessEXT);
+            builder.addExecutionMode(shaderEntry, spv::ExecutionModeNonCoherentColorAttachmentReadEXT);
+            builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
+        }
+
+        if (glslangIntermediate->getNonCoherentDepthAttachmentReadEXT()) {
+            builder.addCapability(spv::CapabilityTileImageDepthReadAccessEXT);
+            builder.addExecutionMode(shaderEntry, spv::ExecutionModeNonCoherentDepthAttachmentReadEXT);
+            builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
+        }
+
+        if (glslangIntermediate->getNonCoherentStencilAttachmentReadEXT()) {
+            builder.addCapability(spv::CapabilityTileImageStencilReadAccessEXT);
+            builder.addExecutionMode(shaderEntry, spv::ExecutionModeNonCoherentStencilAttachmentReadEXT);
+            builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
+        }
+
         if (glslangIntermediate->isDepthReplacing())
             builder.addExecutionMode(shaderEntry, spv::ExecutionModeDepthReplacing);
 
         if (glslangIntermediate->isStencilReplacing())
             builder.addExecutionMode(shaderEntry, spv::ExecutionModeStencilRefReplacingEXT);
 
-#ifndef GLSLANG_WEB
-
         switch(glslangIntermediate->getDepth()) {
         case glslang::EldGreater:   mode = spv::ExecutionModeDepthGreater;   break;
         case glslang::EldLess:      mode = spv::ExecutionModeDepthLess;      break;
@@ -1719,26 +1739,33 @@
             }
             builder.addExtension(spv::E_SPV_EXT_fragment_shader_interlock);
         }
-#endif
     break;
 
-    case EShLangCompute:
+    case EShLangCompute: {
         builder.addCapability(spv::CapabilityShader);
-        if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6) {
-          std::vector<spv::Id> dimConstId;
-          for (int dim = 0; dim < 3; ++dim) {
-            bool specConst = (glslangIntermediate->getLocalSizeSpecId(dim) != glslang::TQualifier::layoutNotSet);
-            dimConstId.push_back(builder.makeUintConstant(glslangIntermediate->getLocalSize(dim), specConst));
-            if (specConst) {
-                builder.addDecoration(dimConstId.back(), spv::DecorationSpecId,
-                                      glslangIntermediate->getLocalSizeSpecId(dim));
+        bool needSizeId = false;
+        for (int dim = 0; dim < 3; ++dim) {
+            if ((glslangIntermediate->getLocalSizeSpecId(dim) != glslang::TQualifier::layoutNotSet)) {
+                needSizeId = true;
+                break;
             }
-          }
-          builder.addExecutionModeId(shaderEntry, spv::ExecutionModeLocalSizeId, dimConstId);
+        }
+        if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6 && needSizeId) {
+            std::vector<spv::Id> dimConstId;
+            for (int dim = 0; dim < 3; ++dim) {
+                bool specConst = (glslangIntermediate->getLocalSizeSpecId(dim) != glslang::TQualifier::layoutNotSet);
+                dimConstId.push_back(builder.makeUintConstant(glslangIntermediate->getLocalSize(dim), specConst));
+                if (specConst) {
+                    builder.addDecoration(dimConstId.back(), spv::DecorationSpecId,
+                                          glslangIntermediate->getLocalSizeSpecId(dim));
+                    needSizeId = true;
+                }
+            }
+            builder.addExecutionModeId(shaderEntry, spv::ExecutionModeLocalSizeId, dimConstId);
         } else {
-          builder.addExecutionMode(shaderEntry, spv::ExecutionModeLocalSize, glslangIntermediate->getLocalSize(0),
-                                                                             glslangIntermediate->getLocalSize(1),
-                                                                             glslangIntermediate->getLocalSize(2));
+            builder.addExecutionMode(shaderEntry, spv::ExecutionModeLocalSize, glslangIntermediate->getLocalSize(0),
+                                                                               glslangIntermediate->getLocalSize(1),
+                                                                               glslangIntermediate->getLocalSize(2));
         }
         if (glslangIntermediate->getLayoutDerivativeModeNone() == glslang::LayoutDerivativeGroupQuads) {
             builder.addCapability(spv::CapabilityComputeDerivativeGroupQuadsNV);
@@ -1750,7 +1777,7 @@
             builder.addExtension(spv::E_SPV_NV_compute_shader_derivatives);
         }
         break;
-#ifndef GLSLANG_WEB
+    }
     case EShLangTessEvaluation:
     case EShLangTessControl:
         builder.addCapability(spv::CapabilityTessellation);
@@ -1837,13 +1864,16 @@
             builder.addCapability(spv::CapabilityRayTracingNV);
             builder.addExtension("SPV_NV_ray_tracing");
         }
-	if (glslangIntermediate->getStage() != EShLangRayGen && glslangIntermediate->getStage() != EShLangCallable)
-	{
-		if (extensions.find("GL_EXT_ray_cull_mask") != extensions.end()) {
-			builder.addCapability(spv::CapabilityRayCullMaskKHR);
-			builder.addExtension("SPV_KHR_ray_cull_mask");
-		}
-	}
+        if (glslangIntermediate->getStage() != EShLangRayGen && glslangIntermediate->getStage() != EShLangCallable) {
+            if (extensions.find("GL_EXT_ray_cull_mask") != extensions.end()) {
+                builder.addCapability(spv::CapabilityRayCullMaskKHR);
+                builder.addExtension("SPV_KHR_ray_cull_mask");
+            }
+            if (extensions.find("GL_EXT_ray_tracing_position_fetch") != extensions.end()) {
+                builder.addCapability(spv::CapabilityRayTracingPositionFetchKHR);
+                builder.addExtension("SPV_KHR_ray_tracing_position_fetch");
+            }
+        }
         break;
     }
     case EShLangTask:
@@ -1887,13 +1917,11 @@
                 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
         }
         break;
-#endif
 
     default:
         break;
     }
 
-#ifndef GLSLANG_WEB
     //
     // Add SPIR-V requirements (GL_EXT_spirv_intrinsics)
     //
@@ -1938,27 +1966,29 @@
             builder.addExecutionModeId(shaderEntry, static_cast<spv::ExecutionMode>(modeId.first), operandIds);
         }
     }
-#endif
 }
 
 // Finish creating SPV, after the traversal is complete.
-void TGlslangToSpvTraverser::finishSpv()
+void TGlslangToSpvTraverser::finishSpv(bool compileOnly)
 {
-    // Finish the entry point function
-    if (! entryPointTerminated) {
-        builder.setBuildPoint(shaderEntry->getLastBlock());
-        builder.leaveFunction();
-    }
+    // If not linking, an entry point is not expected
+    if (!compileOnly) {
+        // Finish the entry point function
+        if (!entryPointTerminated) {
+            builder.setBuildPoint(shaderEntry->getLastBlock());
+            builder.leaveFunction();
+        }
 
-    // finish off the entry-point SPV instruction by adding the Input/Output <id>
-    for (auto it = iOSet.cbegin(); it != iOSet.cend(); ++it)
-        entryPoint->addIdOperand(*it);
+        // finish off the entry-point SPV instruction by adding the Input/Output <id>
+        for (auto it = iOSet.cbegin(); it != iOSet.cend(); ++it)
+            entryPoint->addIdOperand(*it);
+    }
 
     // Add capabilities, extensions, remove unneeded decorations, etc.,
     // based on the resulting SPIR-V.
     // Note: WebGPU code generation must have the opportunity to aggressively
     // prune unreachable merge blocks and continue targets.
-    builder.postProcess();
+    builder.postProcess(compileOnly);
 }
 
 // Write the SPV into 'out'.
@@ -1984,6 +2014,10 @@
 //
 void TGlslangToSpvTraverser::visitSymbol(glslang::TIntermSymbol* symbol)
 {
+    // We update the line information even though no code might be generated here
+    // This is helpful to yield correct lines for control flow instructions
+    builder.setLine(symbol->getLoc().line, symbol->getLoc().getFilename());
+
     SpecConstantOpModeGuard spec_constant_op_mode_setter(&builder);
     if (symbol->getType().isStruct())
         glslangTypeToIdMap[symbol->getType().getStruct()] = symbol->getId();
@@ -2013,7 +2047,7 @@
                 spv::StorageClass sc = builder.getStorageClass(id);
                 // Before SPIR-V 1.4, we only want to include Input and Output.
                 // Starting with SPIR-V 1.4, we want all globals.
-                if ((glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_4 && builder.isGlobalStorage(id)) ||
+                if ((glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_4 && builder.isGlobalVariable(id)) ||
                     (sc == spv::StorageClassInput || sc == spv::StorageClassOutput)) {
                     iOSet.insert(id);
                 }
@@ -2135,6 +2169,9 @@
             node->getRight()->traverse(this);
             spv::Id rValue = accessChainLoad(node->getRight()->getType());
 
+            // reset line number for assignment
+            builder.setLine(node->getLoc().line, node->getLoc().getFilename());
+
             if (node->getOp() != glslang::EOpAssign) {
                 // the left is also an r-value
                 builder.setAccessChain(lValue);
@@ -2499,12 +2536,15 @@
 
         spv::Id length;
         if (node->getOperand()->getType().isCoopMat()) {
-            spec_constant_op_mode_setter.turnOnSpecConstantOpMode();
-
             spv::Id typeId = convertGlslangToSpvType(node->getOperand()->getType());
             assert(builder.isCooperativeMatrixType(typeId));
 
-            length = builder.createCooperativeMatrixLength(typeId);
+            if (node->getOperand()->getType().isCoopMatKHR()) {
+                length = builder.createCooperativeMatrixLengthKHR(typeId);
+            } else {
+                spec_constant_op_mode_setter.turnOnSpecConstantOpMode();
+                length = builder.createCooperativeMatrixLengthNV(typeId);
+            }
         } else {
             glslang::TIntermTyped* block = node->getOperand()->getAsBinaryNode()->getLeft();
             block->traverse(this);
@@ -2561,7 +2601,35 @@
 
     spv::Builder::AccessChain::CoherentFlags lvalueCoherentFlags;
 
-#ifndef GLSLANG_WEB
+    const auto hitObjectOpsWithLvalue = [](glslang::TOperator op) {
+        switch(op) {
+            case glslang::EOpReorderThreadNV:
+            case glslang::EOpHitObjectGetCurrentTimeNV:
+            case glslang::EOpHitObjectGetHitKindNV:
+            case glslang::EOpHitObjectGetPrimitiveIndexNV:
+            case glslang::EOpHitObjectGetGeometryIndexNV:
+            case glslang::EOpHitObjectGetInstanceIdNV:
+            case glslang::EOpHitObjectGetInstanceCustomIndexNV:
+            case glslang::EOpHitObjectGetObjectRayDirectionNV:
+            case glslang::EOpHitObjectGetObjectRayOriginNV:
+            case glslang::EOpHitObjectGetWorldRayDirectionNV:
+            case glslang::EOpHitObjectGetWorldRayOriginNV:
+            case glslang::EOpHitObjectGetWorldToObjectNV:
+            case glslang::EOpHitObjectGetObjectToWorldNV:
+            case glslang::EOpHitObjectGetRayTMaxNV:
+            case glslang::EOpHitObjectGetRayTMinNV:
+            case glslang::EOpHitObjectIsEmptyNV:
+            case glslang::EOpHitObjectIsHitNV:
+            case glslang::EOpHitObjectIsMissNV:
+            case glslang::EOpHitObjectRecordEmptyNV:
+            case glslang::EOpHitObjectGetShaderBindingTableRecordIndexNV:
+            case glslang::EOpHitObjectGetShaderRecordBufferHandleNV:
+                return true;
+            default:
+                return false;
+        }
+    };
+
     if (node->getOp() == glslang::EOpAtomicCounterIncrement ||
         node->getOp() == glslang::EOpAtomicCounterDecrement ||
         node->getOp() == glslang::EOpAtomicCounter          ||
@@ -2575,16 +2643,15 @@
         node->getOp() == glslang::EOpRayQueryGetIntersectionCandidateAABBOpaque ||
         node->getOp() == glslang::EOpRayQueryTerminate ||
         node->getOp() == glslang::EOpRayQueryConfirmIntersection ||
-        (node->getOp() == glslang::EOpSpirvInst && operandNode->getAsTyped()->getQualifier().isSpirvByReference())) {
+        (node->getOp() == glslang::EOpSpirvInst && operandNode->getAsTyped()->getQualifier().isSpirvByReference()) ||
+        hitObjectOpsWithLvalue(node->getOp())) {
         operand = builder.accessChainGetLValue(); // Special case l-value operands
         lvalueCoherentFlags = builder.getAccessChain().coherentFlags;
         lvalueCoherentFlags |= TranslateCoherent(operandNode->getAsTyped()->getType());
     } else if (operandNode->getAsTyped()->getQualifier().isSpirvLiteral()) {
         // Will be translated to a literal value, make a placeholder here
         operand = spv::NoResult;
-    } else
-#endif
-    {
+    } else {
         operand = accessChainLoad(node->getOperand()->getType());
     }
 
@@ -2602,7 +2669,6 @@
         result = createUnaryOperation(node->getOp(), decorations, resultType(), operand,
             node->getOperand()->getBasicType(), lvalueCoherentFlags);
 
-#ifndef GLSLANG_WEB
     // it could be attached to a SPIR-V intruction
     if (!result) {
         if (node->getOp() == glslang::EOpSpirvInst) {
@@ -2632,7 +2698,6 @@
                 return false; // done with this node
         }
     }
-#endif
 
     if (result) {
         if (invertedType) {
@@ -2657,7 +2722,6 @@
             spv::Id one = 0;
             if (node->getBasicType() == glslang::EbtFloat)
                 one = builder.makeFloatConstant(1.0F);
-#ifndef GLSLANG_WEB
             else if (node->getBasicType() == glslang::EbtDouble)
                 one = builder.makeDoubleConstant(1.0);
             else if (node->getBasicType() == glslang::EbtFloat16)
@@ -2668,7 +2732,6 @@
                 one = builder.makeInt16Constant(1);
             else if (node->getBasicType() == glslang::EbtInt64 || node->getBasicType() == glslang::EbtUint64)
                 one = builder.makeInt64Constant(1);
-#endif
             else
                 one = builder.makeIntConstant(1);
             glslang::TOperator op;
@@ -2697,7 +2760,6 @@
 
         return false;
 
-#ifndef GLSLANG_WEB
     case glslang::EOpEmitStreamVertex:
         builder.createNoResultOp(spv::OpEmitStreamVertex, operand);
         return false;
@@ -2710,7 +2772,12 @@
     case glslang::EOpRayQueryConfirmIntersection:
         builder.createNoResultOp(spv::OpRayQueryConfirmIntersectionKHR, operand);
         return false;
-#endif
+    case glslang::EOpReorderThreadNV:
+        builder.createNoResultOp(spv::OpReorderThreadWithHitObjectNV, operand);
+        return false;
+    case glslang::EOpHitObjectRecordEmptyNV:
+        builder.createNoResultOp(spv::OpHitObjectRecordEmptyNV, operand);
+        return false;
 
     default:
         logger->missingFunctionality("unknown glslang unary");
@@ -2775,15 +2842,12 @@
         builder.setAccessChainRValue(result);
 
         return false;
-    }
-#ifndef GLSLANG_WEB
-    else if (node->getOp() == glslang::EOpImageStore ||
+    } else if (node->getOp() == glslang::EOpImageStore ||
         node->getOp() == glslang::EOpImageStoreLod ||
         node->getOp() == glslang::EOpImageAtomicStore) {
         // "imageStore" is a special case, which has no result
         return false;
     }
-#endif
 
     glslang::TOperator binOp = glslang::EOpNull;
     bool reduceComparison = true;
@@ -2809,9 +2873,12 @@
                 // In all cases, still let the traverser visit the children for us.
                 makeFunctions(node->getAsAggregate()->getSequence());
 
-                // Also, we want all globals initializers to go into the beginning of the entry point, before
-                // anything else gets there, so visit out of order, doing them all now.
-                makeGlobalInitializers(node->getAsAggregate()->getSequence());
+                // Global initializers is specific to the shader entry point, which does not exist in compile-only mode
+                if (!options.compileOnly) {
+                    // Also, we want all globals initializers to go into the beginning of the entry point, before
+                    // anything else gets there, so visit out of order, doing them all now.
+                    makeGlobalInitializers(node->getAsAggregate()->getSequence());
+                }
 
                 //Pre process linker objects for ray tracing stages
                 if (glslangIntermediate->isRayTracingStage())
@@ -3002,7 +3069,8 @@
     case glslang::EOpConstructStruct:
     case glslang::EOpConstructTextureSampler:
     case glslang::EOpConstructReference:
-    case glslang::EOpConstructCooperativeMatrix:
+    case glslang::EOpConstructCooperativeMatrixNV:
+    case glslang::EOpConstructCooperativeMatrixKHR:
     {
         builder.setLine(node->getLoc().line, node->getLoc().getFilename());
         std::vector<spv::Id> arguments;
@@ -3019,7 +3087,8 @@
             } else
                 constructed = builder.createOp(spv::OpSampledImage, resultType(), arguments);
         } else if (node->getOp() == glslang::EOpConstructStruct ||
-                 node->getOp() == glslang::EOpConstructCooperativeMatrix ||
+                 node->getOp() == glslang::EOpConstructCooperativeMatrixNV ||
+                 node->getOp() == glslang::EOpConstructCooperativeMatrixKHR ||
                  node->getType().isArray()) {
             std::vector<spv::Id> constituents;
             for (int c = 0; c < (int)arguments.size(); ++c)
@@ -3117,7 +3186,6 @@
         atomic = true;
         break;
 
-#ifndef GLSLANG_WEB
     case glslang::EOpAtomicStore:
         noReturnValue = true;
         // fallthrough
@@ -3194,6 +3262,8 @@
         break;
     case glslang::EOpCooperativeMatrixLoad:
     case glslang::EOpCooperativeMatrixStore:
+    case glslang::EOpCooperativeMatrixLoadNV:
+    case glslang::EOpCooperativeMatrixStoreNV:
         noReturnValue = true;
         break;
     case glslang::EOpBeginInvocationInterlock:
@@ -3201,7 +3271,68 @@
         builder.addExtension(spv::E_SPV_EXT_fragment_shader_interlock);
         noReturnValue = true;
         break;
-#endif
+
+    case glslang::EOpHitObjectTraceRayNV:
+    case glslang::EOpHitObjectTraceRayMotionNV:
+    case glslang::EOpHitObjectGetAttributesNV:
+    case glslang::EOpHitObjectExecuteShaderNV:
+    case glslang::EOpHitObjectRecordEmptyNV:
+    case glslang::EOpHitObjectRecordMissNV:
+    case glslang::EOpHitObjectRecordMissMotionNV:
+    case glslang::EOpHitObjectRecordHitNV:
+    case glslang::EOpHitObjectRecordHitMotionNV:
+    case glslang::EOpHitObjectRecordHitWithIndexNV:
+    case glslang::EOpHitObjectRecordHitWithIndexMotionNV:
+    case glslang::EOpReorderThreadNV:
+        noReturnValue = true;
+        //Fallthrough
+    case glslang::EOpHitObjectIsEmptyNV:
+    case glslang::EOpHitObjectIsMissNV:
+    case glslang::EOpHitObjectIsHitNV:
+    case glslang::EOpHitObjectGetRayTMinNV:
+    case glslang::EOpHitObjectGetRayTMaxNV:
+    case glslang::EOpHitObjectGetObjectRayOriginNV:
+    case glslang::EOpHitObjectGetObjectRayDirectionNV:
+    case glslang::EOpHitObjectGetWorldRayOriginNV:
+    case glslang::EOpHitObjectGetWorldRayDirectionNV:
+    case glslang::EOpHitObjectGetObjectToWorldNV:
+    case glslang::EOpHitObjectGetWorldToObjectNV:
+    case glslang::EOpHitObjectGetInstanceCustomIndexNV:
+    case glslang::EOpHitObjectGetInstanceIdNV:
+    case glslang::EOpHitObjectGetGeometryIndexNV:
+    case glslang::EOpHitObjectGetPrimitiveIndexNV:
+    case glslang::EOpHitObjectGetHitKindNV:
+    case glslang::EOpHitObjectGetCurrentTimeNV:
+    case glslang::EOpHitObjectGetShaderBindingTableRecordIndexNV:
+    case glslang::EOpHitObjectGetShaderRecordBufferHandleNV:
+        builder.addExtension(spv::E_SPV_NV_shader_invocation_reorder);
+        builder.addCapability(spv::CapabilityShaderInvocationReorderNV);
+        break;
+    case glslang::EOpRayQueryGetIntersectionTriangleVertexPositionsEXT:
+        builder.addExtension(spv::E_SPV_KHR_ray_tracing_position_fetch);
+        builder.addCapability(spv::CapabilityRayQueryPositionFetchKHR);
+        noReturnValue = true;
+        break;
+
+    case glslang::EOpImageSampleWeightedQCOM:
+        builder.addCapability(spv::CapabilityTextureSampleWeightedQCOM);
+        builder.addExtension(spv::E_SPV_QCOM_image_processing);
+        break;
+    case glslang::EOpImageBoxFilterQCOM:
+        builder.addCapability(spv::CapabilityTextureBoxFilterQCOM);
+        builder.addExtension(spv::E_SPV_QCOM_image_processing);
+        break;
+    case glslang::EOpImageBlockMatchSADQCOM:
+    case glslang::EOpImageBlockMatchSSDQCOM:
+        builder.addCapability(spv::CapabilityTextureBlockMatchQCOM);
+        builder.addExtension(spv::E_SPV_QCOM_image_processing);
+        break;
+
+    case glslang::EOpFetchMicroTriangleVertexPositionNV:
+    case glslang::EOpFetchMicroTriangleVertexBarycentricNV:
+        builder.addExtension(spv::E_SPV_NV_displacement_micromap);
+        builder.addCapability(spv::CapabilityDisplacementMicromapNV);
+        break;
 
     case glslang::EOpDebugPrintf:
         noReturnValue = true;
@@ -3258,6 +3389,22 @@
                 lvalue = true;
             break;
 
+
+
+        case glslang::EOpHitObjectRecordHitNV:
+        case glslang::EOpHitObjectRecordHitMotionNV:
+        case glslang::EOpHitObjectRecordHitWithIndexNV:
+        case glslang::EOpHitObjectRecordHitWithIndexMotionNV:
+        case glslang::EOpHitObjectTraceRayNV:
+        case glslang::EOpHitObjectTraceRayMotionNV:
+        case glslang::EOpHitObjectExecuteShaderNV:
+        case glslang::EOpHitObjectRecordMissNV:
+        case glslang::EOpHitObjectRecordMissMotionNV:
+        case glslang::EOpHitObjectGetAttributesNV:
+            if (arg == 0)
+                lvalue = true;
+            break;
+
         case glslang::EOpRayQueryInitialize:
         case glslang::EOpRayQueryTerminate:
         case glslang::EOpRayQueryConfirmIntersection:
@@ -3293,7 +3440,6 @@
                 lvalue = true;
             break;
 
-#ifndef GLSLANG_WEB
         case glslang::EOpFrexp:
             if (arg == 1)
                 lvalue = true;
@@ -3347,10 +3493,12 @@
                 lvalue = true;
             break;
         case glslang::EOpCooperativeMatrixLoad:
+        case glslang::EOpCooperativeMatrixLoadNV:
             if (arg == 0 || arg == 1)
                 lvalue = true;
             break;
         case glslang::EOpCooperativeMatrixStore:
+        case glslang::EOpCooperativeMatrixStoreNV:
             if (arg == 1)
                 lvalue = true;
             break;
@@ -3358,7 +3506,15 @@
             if (glslangOperands[arg]->getAsTyped()->getQualifier().isSpirvByReference())
                 lvalue = true;
             break;
-#endif
+        case glslang::EOpReorderThreadNV:
+            //Three variants of reorderThreadNV, two of them use hitObjectNV
+            if (arg == 0 && glslangOperands.size() != 2)
+                lvalue = true;
+            break;
+        case glslang::EOpRayQueryGetIntersectionTriangleVertexPositionsEXT:
+            if (arg == 0 || arg == 2)
+                lvalue = true;
+            break;
         default:
             break;
         }
@@ -3368,9 +3524,10 @@
         else
             glslangOperands[arg]->traverse(this);
 
-#ifndef GLSLANG_WEB
         if (node->getOp() == glslang::EOpCooperativeMatrixLoad ||
-            node->getOp() == glslang::EOpCooperativeMatrixStore) {
+            node->getOp() == glslang::EOpCooperativeMatrixStore ||
+            node->getOp() == glslang::EOpCooperativeMatrixLoadNV ||
+            node->getOp() == glslang::EOpCooperativeMatrixStoreNV) {
 
             if (arg == 1) {
                 // fold "element" parameter into the access chain
@@ -3391,9 +3548,11 @@
                 unsigned int alignment = builder.getAccessChain().alignment;
 
                 int memoryAccess = TranslateMemoryAccess(coherentFlags);
-                if (node->getOp() == glslang::EOpCooperativeMatrixLoad)
+                if (node->getOp() == glslang::EOpCooperativeMatrixLoad ||
+                    node->getOp() == glslang::EOpCooperativeMatrixLoadNV)
                     memoryAccess &= ~spv::MemoryAccessMakePointerAvailableKHRMask;
-                if (node->getOp() == glslang::EOpCooperativeMatrixStore)
+                if (node->getOp() == glslang::EOpCooperativeMatrixStore ||
+                    node->getOp() == glslang::EOpCooperativeMatrixStoreNV)
                     memoryAccess &= ~spv::MemoryAccessMakePointerVisibleKHRMask;
                 if (builder.getStorageClass(builder.getAccessChain().base) ==
                     spv::StorageClassPhysicalStorageBufferEXT) {
@@ -3415,7 +3574,6 @@
                 continue;
             }
         }
-#endif
 
         // for l-values, pass the address, for r-values, pass the value
         if (lvalue) {
@@ -3450,26 +3608,37 @@
                  glslangOp == glslang::EOpRayQueryGetIntersectionObjectRayDirection ||
                  glslangOp == glslang::EOpRayQueryGetIntersectionObjectRayOrigin ||
                  glslangOp == glslang::EOpRayQueryGetIntersectionObjectToWorld ||
-                 glslangOp == glslang::EOpRayQueryGetIntersectionWorldToObject
+                 glslangOp == glslang::EOpRayQueryGetIntersectionWorldToObject ||
+                 glslangOp == glslang::EOpRayQueryGetIntersectionTriangleVertexPositionsEXT
                     )) {
                 bool cond = glslangOperands[arg]->getAsConstantUnion()->getConstArray()[0].getBConst();
                 operands.push_back(builder.makeIntConstant(cond ? 1 : 0));
              } else if ((arg == 10 && glslangOp == glslang::EOpTraceKHR) ||
                         (arg == 11 && glslangOp == glslang::EOpTraceRayMotionNV) ||
-                        (arg == 1  && glslangOp == glslang::EOpExecuteCallableKHR)) {
-                 const int opdNum = glslangOp == glslang::EOpTraceKHR ? 10 : (glslangOp == glslang::EOpTraceRayMotionNV ? 11 : 1);
+                        (arg == 1  && glslangOp == glslang::EOpExecuteCallableKHR) ||
+                        (arg == 1  && glslangOp == glslang::EOpHitObjectExecuteShaderNV) ||
+                        (arg == 11 && glslangOp == glslang::EOpHitObjectTraceRayNV) ||
+                        (arg == 12 && glslangOp == glslang::EOpHitObjectTraceRayMotionNV)) {
                  const int set = glslangOp == glslang::EOpExecuteCallableKHR ? 1 : 0;
-
-                 const int location = glslangOperands[opdNum]->getAsConstantUnion()->getConstArray()[0].getUConst();
+                 const int location = glslangOperands[arg]->getAsConstantUnion()->getConstArray()[0].getUConst();
                  auto itNode = locationToSymbol[set].find(location);
                  visitSymbol(itNode->second);
                  spv::Id symId = getSymbolId(itNode->second);
                  operands.push_back(symId);
-#ifndef GLSLANG_WEB
+            } else if ((arg == 12 && glslangOp == glslang::EOpHitObjectRecordHitNV) ||
+                       (arg == 13 && glslangOp == glslang::EOpHitObjectRecordHitMotionNV) ||
+                       (arg == 11 && glslangOp == glslang::EOpHitObjectRecordHitWithIndexNV) ||
+                       (arg == 12 && glslangOp == glslang::EOpHitObjectRecordHitWithIndexMotionNV) ||
+                       (arg == 1  && glslangOp == glslang::EOpHitObjectGetAttributesNV)) {
+                 const int location = glslangOperands[arg]->getAsConstantUnion()->getConstArray()[0].getUConst();
+                 const int set = 2;
+                 auto itNode = locationToSymbol[set].find(location);
+                 visitSymbol(itNode->second);
+                 spv::Id symId = getSymbolId(itNode->second);
+                 operands.push_back(symId);
              } else if (glslangOperands[arg]->getAsTyped()->getQualifier().isSpirvLiteral()) {
                  // Will be translated to a literal value, make a placeholder here
                  operands.push_back(spv::NoResult);
-#endif
              } else  {
                 operands.push_back(accessChainLoad(glslangOperands[arg]->getAsTyped()->getType()));
              }
@@ -3477,42 +3646,97 @@
     }
 
     builder.setLine(node->getLoc().line, node->getLoc().getFilename());
-#ifndef GLSLANG_WEB
-    if (node->getOp() == glslang::EOpCooperativeMatrixLoad) {
+    if (node->getOp() == glslang::EOpCooperativeMatrixLoad ||
+        node->getOp() == glslang::EOpCooperativeMatrixLoadNV) {
         std::vector<spv::IdImmediate> idImmOps;
 
         idImmOps.push_back(spv::IdImmediate(true, operands[1])); // buf
-        idImmOps.push_back(spv::IdImmediate(true, operands[2])); // stride
-        idImmOps.push_back(spv::IdImmediate(true, operands[3])); // colMajor
+        if (node->getOp() == glslang::EOpCooperativeMatrixLoad) {
+            idImmOps.push_back(spv::IdImmediate(true, operands[3])); // matrixLayout
+            idImmOps.push_back(spv::IdImmediate(true, operands[2])); // stride
+        } else {
+            idImmOps.push_back(spv::IdImmediate(true, operands[2])); // stride
+            idImmOps.push_back(spv::IdImmediate(true, operands[3])); // colMajor
+        }
         idImmOps.insert(idImmOps.end(), memoryAccessOperands.begin(), memoryAccessOperands.end());
         // get the pointee type
         spv::Id typeId = builder.getContainedTypeId(builder.getTypeId(operands[0]));
         assert(builder.isCooperativeMatrixType(typeId));
         // do the op
-        spv::Id result = builder.createOp(spv::OpCooperativeMatrixLoadNV, typeId, idImmOps);
+        spv::Id result = node->getOp() == glslang::EOpCooperativeMatrixLoad
+                       ? builder.createOp(spv::OpCooperativeMatrixLoadKHR, typeId, idImmOps)
+                       : builder.createOp(spv::OpCooperativeMatrixLoadNV, typeId, idImmOps);
         // store the result to the pointer (out param 'm')
         builder.createStore(result, operands[0]);
         result = 0;
-    } else if (node->getOp() == glslang::EOpCooperativeMatrixStore) {
+    } else if (node->getOp() == glslang::EOpCooperativeMatrixStore ||
+               node->getOp() == glslang::EOpCooperativeMatrixStoreNV) {
         std::vector<spv::IdImmediate> idImmOps;
 
         idImmOps.push_back(spv::IdImmediate(true, operands[1])); // buf
         idImmOps.push_back(spv::IdImmediate(true, operands[0])); // object
-        idImmOps.push_back(spv::IdImmediate(true, operands[2])); // stride
-        idImmOps.push_back(spv::IdImmediate(true, operands[3])); // colMajor
+        if (node->getOp() == glslang::EOpCooperativeMatrixStore) {
+            idImmOps.push_back(spv::IdImmediate(true, operands[3])); // matrixLayout
+            idImmOps.push_back(spv::IdImmediate(true, operands[2])); // stride
+        } else {
+            idImmOps.push_back(spv::IdImmediate(true, operands[2])); // stride
+            idImmOps.push_back(spv::IdImmediate(true, operands[3])); // colMajor
+        }
         idImmOps.insert(idImmOps.end(), memoryAccessOperands.begin(), memoryAccessOperands.end());
 
-        builder.createNoResultOp(spv::OpCooperativeMatrixStoreNV, idImmOps);
+        if (node->getOp() == glslang::EOpCooperativeMatrixStore)
+            builder.createNoResultOp(spv::OpCooperativeMatrixStoreKHR, idImmOps);
+        else
+            builder.createNoResultOp(spv::OpCooperativeMatrixStoreNV, idImmOps);
         result = 0;
-    } else
-#endif
-    if (atomic) {
+    } else if (node->getOp() == glslang::EOpRayQueryGetIntersectionTriangleVertexPositionsEXT) {
+        std::vector<spv::IdImmediate> idImmOps;
+
+        idImmOps.push_back(spv::IdImmediate(true, operands[0])); // q
+        idImmOps.push_back(spv::IdImmediate(true, operands[1])); // committed
+
+        spv::Id typeId = builder.makeArrayType(builder.makeVectorType(builder.makeFloatType(32), 3),
+                                               builder.makeUintConstant(3), 0);
+        // do the op
+
+        spv::Op spvOp = spv::OpRayQueryGetIntersectionTriangleVertexPositionsKHR;
+
+        spv::Id result = builder.createOp(spvOp, typeId, idImmOps);
+        // store the result to the pointer (out param 'm')
+        builder.createStore(result, operands[2]);
+        result = 0;
+    } else if (node->getOp() == glslang::EOpCooperativeMatrixMulAdd) {
+        uint32_t matrixOperands = 0;
+
+        // If the optional operand is present, initialize matrixOperands to that value.
+        if (glslangOperands.size() == 4 && glslangOperands[3]->getAsConstantUnion()) {
+            matrixOperands = glslangOperands[3]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        }
+
+        // Determine Cooperative Matrix Operands bits from the signedness of the types.
+        if (isTypeSignedInt(glslangOperands[0]->getAsTyped()->getBasicType()))
+            matrixOperands |= spv::CooperativeMatrixOperandsMatrixASignedComponentsMask;
+        if (isTypeSignedInt(glslangOperands[1]->getAsTyped()->getBasicType()))
+            matrixOperands |= spv::CooperativeMatrixOperandsMatrixBSignedComponentsMask;
+        if (isTypeSignedInt(glslangOperands[2]->getAsTyped()->getBasicType()))
+            matrixOperands |= spv::CooperativeMatrixOperandsMatrixCSignedComponentsMask;
+        if (isTypeSignedInt(node->getBasicType()))
+            matrixOperands |= spv::CooperativeMatrixOperandsMatrixResultSignedComponentsMask;
+
+        std::vector<spv::IdImmediate> idImmOps;
+        idImmOps.push_back(spv::IdImmediate(true, operands[0]));
+        idImmOps.push_back(spv::IdImmediate(true, operands[1]));
+        idImmOps.push_back(spv::IdImmediate(true, operands[2]));
+        if (matrixOperands != 0)
+            idImmOps.push_back(spv::IdImmediate(false, matrixOperands));
+
+        result = builder.createOp(spv::OpCooperativeMatrixMulAddKHR, resultType(), idImmOps);
+    } else if (atomic) {
         // Handle all atomics
         glslang::TBasicType typeProxy = (node->getOp() == glslang::EOpAtomicStore)
             ? node->getSequence()[0]->getAsTyped()->getBasicType() : node->getBasicType();
         result = createAtomicOperation(node->getOp(), precision, resultType(), operands, typeProxy,
             lvalueCoherentFlags);
-#ifndef GLSLANG_WEB
     } else if (node->getOp() == glslang::EOpSpirvInst) {
         const auto& spirvInst = node->getSpirvInstruction();
         if (spirvInst.set == "") {
@@ -3539,7 +3763,6 @@
                 spirvInst.id, operands);
         }
         noReturnValue = node->getBasicType() == glslang::EbtVoid;
-#endif
     } else if (node->getOp() == glslang::EOpDebugPrintf) {
         if (!nonSemanticDebugPrintf) {
             nonSemanticDebugPrintf = builder.import("NonSemantic.DebugPrintf");
@@ -3656,10 +3879,11 @@
     // Find a way of executing both sides and selecting the right result.
     const auto executeBothSides = [&]() -> void {
         // execute both sides
+        spv::Id resultType = convertGlslangToSpvType(node->getType());
         node->getTrueBlock()->traverse(this);
         spv::Id trueValue = accessChainLoad(node->getTrueBlock()->getAsTyped()->getType());
         node->getFalseBlock()->traverse(this);
-        spv::Id falseValue = accessChainLoad(node->getTrueBlock()->getAsTyped()->getType());
+        spv::Id falseValue = accessChainLoad(node->getFalseBlock()->getAsTyped()->getType());
 
         builder.setLine(node->getLoc().line, node->getLoc().getFilename());
 
@@ -3668,8 +3892,8 @@
             return;
 
         // emit code to select between trueValue and falseValue
-
-        // see if OpSelect can handle it
+        // see if OpSelect can handle the result type, and that the SPIR-V types
+        // of the inputs match the result type.
         if (isOpSelectable()) {
             // Emit OpSelect for this selection.
 
@@ -3681,10 +3905,18 @@
                                                                        builder.getNumComponents(trueValue)));
             }
 
+            // If the types do not match, it is because of mismatched decorations on aggregates.
+            // Since isOpSelectable only lets us get here for SPIR-V >= 1.4, we can use OpCopyObject
+            // to get matching types.
+            if (builder.getTypeId(trueValue) != resultType) {
+                trueValue = builder.createUnaryOp(spv::OpCopyLogical, resultType, trueValue);
+            }
+            if (builder.getTypeId(falseValue) != resultType) {
+                falseValue = builder.createUnaryOp(spv::OpCopyLogical, resultType, falseValue);
+            }
+
             // OpSelect
-            result = builder.createTriOp(spv::OpSelect,
-                                         convertGlslangToSpvType(node->getType()), condition,
-                                                                 trueValue, falseValue);
+            result = builder.createTriOp(spv::OpSelect, resultType, condition, trueValue, falseValue);
 
             builder.clearAccessChain();
             builder.setAccessChainRValue(result);
@@ -3692,7 +3924,7 @@
             // We need control flow to select the result.
             // TODO: Once SPIR-V OpSelect allows arbitrary types, eliminate this path.
             result = builder.createVariable(TranslatePrecisionDecoration(node->getType()),
-                spv::StorageClassFunction, convertGlslangToSpvType(node->getType()));
+                spv::StorageClassFunction, resultType);
 
             // Selection control:
             const spv::SelectionControlMask control = TranslateSelectionControl(*node);
@@ -3701,10 +3933,15 @@
             spv::Builder::If ifBuilder(condition, control, builder);
 
             // emit the "then" statement
-            builder.createStore(trueValue, result);
+            builder.clearAccessChain();
+            builder.setAccessChainLValue(result);
+            multiTypeStore(node->getType(), trueValue);
+
             ifBuilder.makeBeginElse();
             // emit the "else" statement
-            builder.createStore(falseValue, result);
+            builder.clearAccessChain();
+            builder.setAccessChainLValue(result);
+            multiTypeStore(node->getType(), falseValue);
 
             // finish off the control flow
             ifBuilder.makeEndIf();
@@ -3731,16 +3968,26 @@
         // emit the "then" statement
         if (node->getTrueBlock() != nullptr) {
             node->getTrueBlock()->traverse(this);
-            if (result != spv::NoResult)
-                builder.createStore(accessChainLoad(node->getTrueBlock()->getAsTyped()->getType()), result);
+            if (result != spv::NoResult) {
+                spv::Id load = accessChainLoad(node->getTrueBlock()->getAsTyped()->getType());
+
+                builder.clearAccessChain();
+                builder.setAccessChainLValue(result);
+                multiTypeStore(node->getType(), load);
+            }
         }
 
         if (node->getFalseBlock() != nullptr) {
             ifBuilder.makeBeginElse();
             // emit the "else" statement
             node->getFalseBlock()->traverse(this);
-            if (result != spv::NoResult)
-                builder.createStore(accessChainLoad(node->getFalseBlock()->getAsTyped()->getType()), result);
+            if (result != spv::NoResult) {
+                spv::Id load = accessChainLoad(node->getFalseBlock()->getAsTyped()->getType());
+
+                builder.clearAccessChain();
+                builder.setAccessChainLValue(result);
+                multiTypeStore(node->getType(), load);
+            }
         }
 
         // finish off the control flow
@@ -3820,10 +4067,8 @@
 
 void TGlslangToSpvTraverser::visitConstantUnion(glslang::TIntermConstantUnion* node)
 {
-#ifndef GLSLANG_WEB
     if (node->getQualifier().isSpirvLiteral())
         return; // Translated to a literal value, skip further processing
-#endif
 
     int nextConst = 0;
     spv::Id constant = createSpvConstantFromConstUnionArray(node->getType(), node->getConstArray(), nextConst, false);
@@ -3954,7 +4199,6 @@
         builder.clearAccessChain();
         break;
 
-#ifndef GLSLANG_WEB
     case glslang::EOpDemote:
         builder.createNoResultOp(spv::OpDemoteToHelperInvocationEXT);
         builder.addExtension(spv::E_SPV_EXT_demote_to_helper_invocation);
@@ -3966,7 +4210,6 @@
     case glslang::EOpIgnoreIntersectionKHR:
         builder.makeStatementTerminator(spv::OpIgnoreIntersectionKHR, "post-ignoreIntersectionKHR");
         break;
-#endif
 
     default:
         assert(0);
@@ -4008,7 +4251,6 @@
             else
                 builder.addCapability(spv::CapabilityStorageUniform16);
             break;
-#ifndef GLSLANG_WEB
         case spv::StorageClassPushConstant:
             builder.addIncorporatedExtension(spv::E_SPV_KHR_16bit_storage, spv::Spv_1_3);
             builder.addCapability(spv::CapabilityStoragePushConstant16);
@@ -4018,7 +4260,6 @@
             builder.addIncorporatedExtension(spv::E_SPV_KHR_16bit_storage, spv::Spv_1_3);
             builder.addCapability(spv::CapabilityStorageUniformBufferBlock16);
             break;
-#endif
         default:
             if (storageClass == spv::StorageClassWorkgroup &&
                 node->getType().getBasicType() == glslang::EbtBlock) {
@@ -4077,7 +4318,6 @@
         case glslang::EbtInt:      return builder.makeIntType(32);
         case glslang::EbtUint:     return builder.makeUintType(32);
         case glslang::EbtFloat:    return builder.makeFloatType(32);
-#ifndef GLSLANG_WEB
         case glslang::EbtFloat16:
             builder.addExtension(spv::E_SPV_AMD_gpu_shader_half_float_fetch);
             builder.addCapability(spv::CapabilityFloat16ImageAMD);
@@ -4090,7 +4330,6 @@
             builder.addExtension(spv::E_SPV_EXT_shader_image_int64);
             builder.addCapability(spv::CapabilityInt64ImageEXT);
             return builder.makeUintType(64);
-#endif
         default:
             assert(0);
             return builder.makeFloatType(32);
@@ -4135,6 +4374,16 @@
     return convertGlslangToSpvType(type, getExplicitLayout(type), type.getQualifier(), false, forwardReferenceOnly);
 }
 
+spv::LinkageType TGlslangToSpvTraverser::convertGlslangLinkageToSpv(glslang::TLinkType linkType)
+{
+    switch (linkType) {
+    case glslang::ELinkExport:
+        return spv::LinkageTypeExport;
+    default:
+        return spv::LinkageTypeMax;
+    }
+}
+
 // Do full recursive conversion of an arbitrary glslang type to a SPIR-V Id.
 // explicitLayout can be kept the same throughout the hierarchical recursive walk.
 // Mutually recursive with convertGlslangStructToSpvType().
@@ -4166,7 +4415,6 @@
     case glslang::EbtFloat:
         spvType = builder.makeFloatType(32);
         break;
-#ifndef GLSLANG_WEB
     case glslang::EbtDouble:
         spvType = builder.makeFloatType(64);
         break;
@@ -4244,7 +4492,6 @@
             }
         }
         break;
-#endif
     case glslang::EbtSampler:
         {
             const glslang::TSampler& sampler = type.getSampler();
@@ -4286,7 +4533,13 @@
     case glslang::EbtString:
         // no type used for OpString
         return 0;
-#ifndef GLSLANG_WEB
+
+    case glslang::EbtHitObjectNV: {
+        builder.addExtension(spv::E_SPV_NV_shader_invocation_reorder);
+        builder.addCapability(spv::CapabilityShaderInvocationReorderNV);
+        spvType = builder.makeHitObjectNVType();
+    }
+    break;
     case glslang::EbtSpirvType: {
         // GL_EXT_spirv_intrinsics
         const auto& spirvType = type.getSpirvType();
@@ -4294,50 +4547,57 @@
 
         std::vector<spv::IdImmediate> operands;
         for (const auto& typeParam : spirvType.typeParams) {
-            // Constant expression
-            if (typeParam.constant->isLiteral()) {
-                if (typeParam.constant->getBasicType() == glslang::EbtFloat) {
-                    float floatValue = static_cast<float>(typeParam.constant->getConstArray()[0].getDConst());
-                    unsigned literal;
-                    static_assert(sizeof(literal) == sizeof(floatValue), "sizeof(unsigned) != sizeof(float)");
-                    memcpy(&literal, &floatValue, sizeof(literal));
-                    operands.push_back({false, literal});
-                } else if (typeParam.constant->getBasicType() == glslang::EbtInt) {
-                    unsigned literal = typeParam.constant->getConstArray()[0].getIConst();
-                    operands.push_back({false, literal});
-                } else if (typeParam.constant->getBasicType() == glslang::EbtUint) {
-                    unsigned literal = typeParam.constant->getConstArray()[0].getUConst();
-                    operands.push_back({false, literal});
-                } else if (typeParam.constant->getBasicType() == glslang::EbtBool) {
-                    unsigned literal = typeParam.constant->getConstArray()[0].getBConst();
-                    operands.push_back({false, literal});
-                } else if (typeParam.constant->getBasicType() == glslang::EbtString) {
-                    auto str = typeParam.constant->getConstArray()[0].getSConst()->c_str();
-                    unsigned literal = 0;
-                    char* literalPtr = reinterpret_cast<char*>(&literal);
-                    unsigned charCount = 0;
-                    char ch = 0;
-                    do {
-                        ch = *(str++);
-                        *(literalPtr++) = ch;
-                        ++charCount;
-                        if (charCount == 4) {
-                            operands.push_back({false, literal});
-                            literalPtr = reinterpret_cast<char*>(&literal);
-                            charCount = 0;
-                        }
-                    } while (ch != 0);
-
-                    // Partial literal is padded with 0
-                    if (charCount > 0) {
-                        for (; charCount < 4; ++charCount)
-                            *(literalPtr++) = 0;
+            if (typeParam.getAsConstant() != nullptr) {
+                // Constant expression
+                auto constant = typeParam.getAsConstant();
+                if (constant->isLiteral()) {
+                    if (constant->getBasicType() == glslang::EbtFloat) {
+                        float floatValue = static_cast<float>(constant->getConstArray()[0].getDConst());
+                        unsigned literal;
+                        static_assert(sizeof(literal) == sizeof(floatValue), "sizeof(unsigned) != sizeof(float)");
+                        memcpy(&literal, &floatValue, sizeof(literal));
                         operands.push_back({false, literal});
-                    }
+                    } else if (constant->getBasicType() == glslang::EbtInt) {
+                        unsigned literal = constant->getConstArray()[0].getIConst();
+                        operands.push_back({false, literal});
+                    } else if (constant->getBasicType() == glslang::EbtUint) {
+                        unsigned literal = constant->getConstArray()[0].getUConst();
+                        operands.push_back({false, literal});
+                    } else if (constant->getBasicType() == glslang::EbtBool) {
+                        unsigned literal = constant->getConstArray()[0].getBConst();
+                        operands.push_back({false, literal});
+                    } else if (constant->getBasicType() == glslang::EbtString) {
+                        auto str = constant->getConstArray()[0].getSConst()->c_str();
+                        unsigned literal = 0;
+                        char* literalPtr = reinterpret_cast<char*>(&literal);
+                        unsigned charCount = 0;
+                        char ch = 0;
+                        do {
+                            ch = *(str++);
+                            *(literalPtr++) = ch;
+                            ++charCount;
+                            if (charCount == 4) {
+                                operands.push_back({false, literal});
+                                literalPtr = reinterpret_cast<char*>(&literal);
+                                charCount = 0;
+                            }
+                        } while (ch != 0);
+
+                        // Partial literal is padded with 0
+                        if (charCount > 0) {
+                            for (; charCount < 4; ++charCount)
+                                *(literalPtr++) = 0;
+                            operands.push_back({false, literal});
+                        }
+                    } else
+                        assert(0); // Unexpected type
                 } else
-                    assert(0); // Unexpected type
-            } else
-                operands.push_back({true, createSpvConstant(*typeParam.constant)});
+                    operands.push_back({true, createSpvConstant(*constant)});
+            } else {
+                // Type specifier
+                assert(typeParam.getAsType() != nullptr);
+                operands.push_back({true, convertGlslangToSpvType(*typeParam.getAsType())});
+            }
         }
 
         assert(spirvInst.set == ""); // Currently, couldn't be extended instructions.
@@ -4345,7 +4605,6 @@
 
         break;
     }
-#endif
     default:
         assert(0);
         break;
@@ -4359,9 +4618,10 @@
             spvType = builder.makeVectorType(spvType, type.getVectorSize());
     }
 
-    if (type.isCoopMat()) {
+    if (type.isCoopMatNV()) {
         builder.addCapability(spv::CapabilityCooperativeMatrixNV);
         builder.addExtension(spv::E_SPV_NV_cooperative_matrix);
+
         if (type.getBasicType() == glslang::EbtFloat16)
             builder.addCapability(spv::CapabilityFloat16);
         if (type.getBasicType() == glslang::EbtUint8 ||
@@ -4369,11 +4629,29 @@
             builder.addCapability(spv::CapabilityInt8);
         }
 
-        spv::Id scope = makeArraySizeId(*type.getTypeParameters(), 1);
-        spv::Id rows = makeArraySizeId(*type.getTypeParameters(), 2);
-        spv::Id cols = makeArraySizeId(*type.getTypeParameters(), 3);
+        spv::Id scope = makeArraySizeId(*type.getTypeParameters()->arraySizes, 1);
+        spv::Id rows = makeArraySizeId(*type.getTypeParameters()->arraySizes, 2);
+        spv::Id cols = makeArraySizeId(*type.getTypeParameters()->arraySizes, 3);
 
-        spvType = builder.makeCooperativeMatrixType(spvType, scope, rows, cols);
+        spvType = builder.makeCooperativeMatrixTypeNV(spvType, scope, rows, cols);
+    }
+
+    if (type.isCoopMatKHR()) {
+        builder.addCapability(spv::CapabilityCooperativeMatrixKHR);
+        builder.addExtension(spv::E_SPV_KHR_cooperative_matrix);
+
+        if (type.getBasicType() == glslang::EbtFloat16)
+            builder.addCapability(spv::CapabilityFloat16);
+        if (type.getBasicType() == glslang::EbtUint8 || type.getBasicType() == glslang::EbtInt8) {
+            builder.addCapability(spv::CapabilityInt8);
+        }
+
+        spv::Id scope = makeArraySizeId(*type.getTypeParameters()->arraySizes, 0);
+        spv::Id rows = makeArraySizeId(*type.getTypeParameters()->arraySizes, 1);
+        spv::Id cols = makeArraySizeId(*type.getTypeParameters()->arraySizes, 2);
+        spv::Id use = builder.makeUintConstant(type.getCoopMatKHRuse());
+
+        spvType = builder.makeCooperativeMatrixTypeKHR(spvType, scope, rows, cols, use);
     }
 
     if (type.isArray()) {
@@ -4414,12 +4692,10 @@
         if (type.isSizedArray())
             spvType = builder.makeArrayType(spvType, makeArraySizeId(*type.getArraySizes(), 0), stride);
         else {
-#ifndef GLSLANG_WEB
             if (!lastBufferBlockMember) {
                 builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5);
                 builder.addCapability(spv::CapabilityRuntimeDescriptorArrayEXT);
             }
-#endif
             spvType = builder.makeRuntimeArray(spvType);
         }
         if (stride > 0)
@@ -4435,7 +4711,6 @@
 //
 bool TGlslangToSpvTraverser::filterMember(const glslang::TType& member)
 {
-#ifndef GLSLANG_WEB
     auto& extensions = glslangIntermediate->getRequestedExtensions();
 
     if (member.getFieldName() == "gl_SecondaryViewportMaskNV" &&
@@ -4445,6 +4720,12 @@
         extensions.find("GL_NV_stereo_view_rendering") == extensions.end())
         return true;
 
+    if (glslangIntermediate->getStage() == EShLangMesh) {
+        if (member.getFieldName() == "gl_PrimitiveShadingRateEXT" &&
+            extensions.find("GL_EXT_fragment_shading_rate") == extensions.end())
+            return true;
+    }
+
     if (glslangIntermediate->getStage() != EShLangMesh) {
         if (member.getFieldName() == "gl_ViewportMask" &&
             extensions.find("GL_NV_viewport_array2") == extensions.end())
@@ -4456,7 +4737,6 @@
             extensions.find("GL_NVX_multiview_per_view_attributes") == extensions.end())
             return true;
     }
-#endif
 
     return false;
 };
@@ -4537,7 +4817,7 @@
         structMap[explicitLayout][qualifier.layoutMatrix][glslangMembers] = spvType;
 
     // Decorate it
-    decorateStructType(type, glslangMembers, explicitLayout, qualifier, spvType);
+    decorateStructType(type, glslangMembers, explicitLayout, qualifier, spvType, spvMembers);
 
     for (int i = 0; i < (int)deferredForwardPointers.size(); ++i) {
         auto it = deferredForwardPointers[i];
@@ -4551,7 +4831,8 @@
                                                 const glslang::TTypeList* glslangMembers,
                                                 glslang::TLayoutPacking explicitLayout,
                                                 const glslang::TQualifier& qualifier,
-                                                spv::Id spvType)
+                                                spv::Id spvType,
+                                                const std::vector<spv::Id>& spvMembers)
 {
     // Name and decorate the non-hidden members
     int offset = -1;
@@ -4586,14 +4867,11 @@
                 glslangIntermediate->getSource() == glslang::EShSourceHlsl) {
                 builder.addMemberDecoration(spvType, member, TranslateInterpolationDecoration(memberQualifier));
                 builder.addMemberDecoration(spvType, member, TranslateAuxiliaryStorageDecoration(memberQualifier));
-#ifndef GLSLANG_WEB
                 addMeshNVDecoration(spvType, member, memberQualifier);
-#endif
             }
         }
         builder.addMemberDecoration(spvType, member, TranslateInvariantDecoration(memberQualifier));
 
-#ifndef GLSLANG_WEB
         if (type.getBasicType() == glslang::EbtBlock &&
             qualifier.storage == glslang::EvqBuffer) {
             // Add memory decorations only to top-level members of shader storage block
@@ -4603,8 +4881,6 @@
                 builder.addMemberDecoration(spvType, member, memory[i]);
         }
 
-#endif
-
         // Location assignment was already completed correctly by the front end,
         // just track whether a member needs to be decorated.
         // Ignore member locations if the container is an array, as that's
@@ -4637,7 +4913,6 @@
         if (builtIn != spv::BuiltInMax)
             builder.addMemberDecoration(spvType, member, spv::DecorationBuiltIn, (int)builtIn);
 
-#ifndef GLSLANG_WEB
         // nonuniform
         builder.addMemberDecoration(spvType, member, TranslateNonUniformDecoration(glslangMember.getQualifier()));
 
@@ -4699,19 +4974,30 @@
                 builder.addDecoration(spvType, static_cast<spv::Decoration>(decorateString.first), strings);
             }
         }
-#endif
     }
 
     // Decorate the structure
     builder.addDecoration(spvType, TranslateLayoutDecoration(type, qualifier.layoutMatrix));
-    builder.addDecoration(spvType, TranslateBlockDecoration(type, glslangIntermediate->usingStorageBuffer()));
+    const auto basicType = type.getBasicType();
+    const auto typeStorageQualifier = type.getQualifier().storage;
+    if (basicType == glslang::EbtBlock) {
+        builder.addDecoration(spvType, TranslateBlockDecoration(typeStorageQualifier, glslangIntermediate->usingStorageBuffer()));
+    } else if (basicType == glslang::EbtStruct && glslangIntermediate->getSpv().vulkan > 0) {
+        const auto hasRuntimeArray = !spvMembers.empty() && builder.getOpCode(spvMembers.back()) == spv::OpTypeRuntimeArray;
+        if (hasRuntimeArray) {
+            builder.addDecoration(spvType, TranslateBlockDecoration(typeStorageQualifier, glslangIntermediate->usingStorageBuffer()));
+        }
+    }
+
+    if (qualifier.hasHitObjectShaderRecordNV())
+        builder.addDecoration(spvType, spv::DecorationHitObjectShaderRecordBufferNV);
 }
 
 // Turn the expression forming the array size into an id.
 // This is not quite trivial, because of specialization constants.
 // Sometimes, a raw constant is turned into an Id, and sometimes
 // a specialization constant expression is.
-spv::Id TGlslangToSpvTraverser::makeArraySizeId(const glslang::TArraySizes& arraySizes, int dim)
+spv::Id TGlslangToSpvTraverser::makeArraySizeId(const glslang::TArraySizes& arraySizes, int dim, bool allowZero)
 {
     // First, see if this is sized with a node, meaning a specialization constant:
     glslang::TIntermTyped* specNode = arraySizes.getDimNode(dim);
@@ -4725,7 +5011,10 @@
 
     // Otherwise, need a compile-time (front end) size, get it:
     int size = arraySizes.getDimSize(dim);
-    assert(size > 0);
+
+    if (!allowZero)
+        assert(size > 0);
+
     return builder.makeUintConstant(size);
 }
 
@@ -4741,6 +5030,16 @@
     spv::Builder::AccessChain::CoherentFlags coherentFlags = builder.getAccessChain().coherentFlags;
     coherentFlags |= TranslateCoherent(type);
 
+    spv::MemoryAccessMask accessMask = spv::MemoryAccessMask(TranslateMemoryAccess(coherentFlags) & ~spv::MemoryAccessMakePointerAvailableKHRMask);
+    // If the value being loaded is HelperInvocation, SPIR-V 1.6 is being generated (so that
+    // SPV_EXT_demote_to_helper_invocation is in core) and the memory model is in use, add
+    // the Volatile MemoryAccess semantic.
+    if (type.getQualifier().builtIn == glslang::EbvHelperInvocation &&
+        glslangIntermediate->usingVulkanMemoryModel() &&
+        glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6) {
+        accessMask = spv::MemoryAccessMask(accessMask | spv::MemoryAccessVolatileMask);
+    }
+
     unsigned int alignment = builder.getAccessChain().alignment;
     alignment |= type.getBufferReferenceAlignment();
 
@@ -4748,7 +5047,7 @@
         TranslateNonUniformDecoration(builder.getAccessChain().coherentFlags),
         TranslateNonUniformDecoration(type.getQualifier()),
         nominalTypeId,
-        spv::MemoryAccessMask(TranslateMemoryAccess(coherentFlags) & ~spv::MemoryAccessMakePointerAvailableKHRMask),
+        accessMask,
         TranslateMemoryScope(coherentFlags),
         alignment);
 
@@ -5020,7 +5319,6 @@
     switch (glslangBuiltIn)
     {
     case glslang::EbvPointSize:
-#ifndef GLSLANG_WEB
     case glslang::EbvClipDistance:
     case glslang::EbvCullDistance:
     case glslang::EbvViewportMaskNV:
@@ -5036,7 +5334,6 @@
     case glslang::EbvLayerPerViewNV:
     case glslang::EbvMeshViewCountNV:
     case glslang::EbvMeshViewIndicesNV:
-#endif
         // Generate the associated capability.  Delegate to TranslateBuiltInDecoration.
         // Alternately, we could just call this for any glslang built-in, since the
         // capability already guards against duplicates.
@@ -5075,10 +5372,8 @@
         return true;
     if (glslangIntermediate->getSource() == glslang::EShSourceHlsl)
         return paramType.getBasicType() == glslang::EbtBlock;
-    return paramType.containsOpaque() ||                                                       // sampler, etc.
-#ifndef GLSLANG_WEB
+    return (paramType.containsOpaque() && !glslangIntermediate->getBindlessMode()) ||       // sampler, etc.
            paramType.getQualifier().isSpirvByReference() ||                                    // spirv_by_reference
-#endif
            (paramType.getBasicType() == glslang::EbtBlock && qualifier == glslang::EvqBuffer); // SSBO
 }
 
@@ -5156,10 +5451,10 @@
         }
 
         spv::Block* functionBlock;
-        spv::Function *function = builder.makeFunctionEntry(TranslatePrecisionDecoration(glslFunction->getType()),
-                                                            convertGlslangToSpvType(glslFunction->getType()),
-                                                            glslFunction->getName().c_str(), paramTypes, paramNames,
-                                                            paramDecorations, &functionBlock);
+        spv::Function* function = builder.makeFunctionEntry(
+            TranslatePrecisionDecoration(glslFunction->getType()), convertGlslangToSpvType(glslFunction->getType()),
+            glslFunction->getName().c_str(), convertGlslangLinkageToSpv(glslFunction->getLinkType()), paramTypes,
+            paramNames, paramDecorations, &functionBlock);
         if (implicitThis)
             function->setImplicitThis();
 
@@ -5222,6 +5517,10 @@
                     set = 1;
                     break;
 
+                case glslang::EvqHitObjectAttrNV:
+                    set = 2;
+                    break;
+
                 default:
                     set = -1;
                 }
@@ -5258,23 +5557,18 @@
 
     glslang::TSampler sampler = {};
     bool cubeCompare = false;
-#ifndef GLSLANG_WEB
     bool f16ShadowCompare = false;
-#endif
     if (node.isTexture() || node.isImage()) {
         sampler = glslangArguments[0]->getAsTyped()->getType().getSampler();
         cubeCompare = sampler.dim == glslang::EsdCube && sampler.arrayed && sampler.shadow;
-#ifndef GLSLANG_WEB
         f16ShadowCompare = sampler.shadow &&
             glslangArguments[1]->getAsTyped()->getType().getBasicType() == glslang::EbtFloat16;
-#endif
     }
 
     for (int i = 0; i < (int)glslangArguments.size(); ++i) {
         builder.clearAccessChain();
         glslangArguments[i]->traverse(this);
 
-#ifndef GLSLANG_WEB
         // Special case l-value operands
         bool lvalue = false;
         switch (node.getOp()) {
@@ -5370,6 +5664,10 @@
             if (i == 7)
                 lvalue = true;
             break;
+        case glslang::EOpRayQueryGetIntersectionTriangleVertexPositionsEXT:
+            if (i == 2)
+                lvalue = true;
+            break;
         default:
             break;
         }
@@ -5381,7 +5679,6 @@
             builder.addDecoration(lvalue_id, TranslateNonUniformDecoration(lvalueCoherentFlags));
             lvalueCoherentFlags |= TranslateCoherent(glslangArguments[i]->getAsTyped()->getType());
         } else
-#endif
             arguments.push_back(accessChainLoad(glslangArguments[i]->getAsTyped()->getType()));
     }
 }
@@ -5406,13 +5703,9 @@
                                         ? node->getAsAggregate()->getSequence()[0]->getAsTyped()->getType()
                                         : node->getAsUnaryNode()->getOperand()->getAsTyped()->getType();
     const glslang::TSampler sampler = imageType.getSampler();
-#ifdef GLSLANG_WEB
-    const bool f16ShadowCompare = false;
-#else
     bool f16ShadowCompare = (sampler.shadow && node->getAsAggregate())
             ? node->getAsAggregate()->getSequence()[1]->getAsTyped()->getType().getBasicType() == glslang::EbtFloat16
             : false;
-#endif
 
     const auto signExtensionMask = [&]() {
         if (builder.getSpvVersion() >= spv::Spv_1_4) {
@@ -5458,7 +5751,6 @@
                 return builder.createTextureQueryCall(spv::OpImageQuerySizeLod, params, isUnsignedResult);
             } else
                 return builder.createTextureQueryCall(spv::OpImageQuerySize, params, isUnsignedResult);
-#ifndef GLSLANG_WEB
         case glslang::EOpImageQuerySamples:
         case glslang::EOpTextureQuerySamples:
             return builder.createTextureQueryCall(spv::OpImageQuerySamples, params, isUnsignedResult);
@@ -5469,7 +5761,6 @@
             return builder.createTextureQueryCall(spv::OpImageQueryLevels, params, isUnsignedResult);
         case glslang::EOpSparseTexelsResident:
             return builder.createUnaryOp(spv::OpImageSparseTexelsResident, builder.makeBoolType(), arguments[0]);
-#endif
         default:
             assert(0);
             break;
@@ -5529,6 +5820,17 @@
             return result;
         }
 
+        if (cracked.attachmentEXT) {
+            if (opIt != arguments.end()) {
+                spv::IdImmediate sample = { true, *opIt };
+                operands.push_back(sample);
+            }
+            spv::Id result = builder.createOp(spv::OpColorAttachmentReadEXT, resultType(), operands);
+            builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
+            builder.setPrecision(result, precision);
+            return result;
+        }
+
         spv::IdImmediate coord = { true, *(opIt++) };
         operands.push_back(coord);
         if (node->getOp() == glslang::EOpImageLoad || node->getOp() == glslang::EOpImageLoadLod) {
@@ -5700,7 +6002,6 @@
         }
     }
 
-#ifndef GLSLANG_WEB
     // Check for fragment mask functions other than queries
     if (cracked.fragMask) {
         assert(sampler.ms);
@@ -5734,7 +6035,6 @@
         builder.addCapability(spv::CapabilityFragmentMaskAMD);
         return builder.createOp(fragMaskOp, resultType(), operands);
     }
-#endif
 
     // Check for texture functions other than queries
     bool sparse = node->isSparseTexture();
@@ -5768,7 +6068,6 @@
             bias = true;
     }
 
-#ifndef GLSLANG_WEB
     if (cracked.gather) {
         const auto& sourceExtensions = glslangIntermediate->getRequestedExtensions();
         if (bias || cracked.lod ||
@@ -5777,7 +6076,6 @@
             builder.addCapability(spv::CapabilityImageGatherBiasLodAMD);
         }
     }
-#endif
 
     // set the rest of the arguments
 
@@ -5837,7 +6135,6 @@
         ++extraArgs;
     }
 
-#ifndef GLSLANG_WEB
     // lod clamp
     if (cracked.lodClamp) {
         params.lodClamp = arguments[2 + extraArgs];
@@ -5866,14 +6163,13 @@
         resultStruct = arguments[4 + extraArgs];
         extraArgs += 3;
     }
-#endif
+
     // bias
     if (bias) {
         params.bias = arguments[2 + extraArgs];
         ++extraArgs;
     }
 
-#ifndef GLSLANG_WEB
     if (imageFootprint) {
         builder.addExtension(spv::E_SPV_NV_shader_image_footprint);
         builder.addCapability(spv::CapabilityImageFootprintNV);
@@ -5931,7 +6227,6 @@
         }
         return builder.createCompositeExtract(res, resultType(), 0);
     }
-#endif
 
     // projective component (might not to move)
     // GLSL: "The texture coordinates consumed from P, not including the last component of P,
@@ -5956,7 +6251,6 @@
         }
     }
 
-#ifndef GLSLANG_WEB
     // nonprivate
     if (imageType.getQualifier().nonprivate) {
         params.nonprivate = true;
@@ -5966,7 +6260,6 @@
     if (imageType.getQualifier().volatil) {
         params.volatil = true;
     }
-#endif
 
     std::vector<spv::Id> result( 1,
         builder.createTextureCall(precision, resultType(), sparse, cracked.fetch, cracked.proj, cracked.gather,
@@ -6620,7 +6913,6 @@
     case glslang::EOpUnpackHalf2x16:
         libCall = spv::GLSLstd450UnpackHalf2x16;
         break;
-#ifndef GLSLANG_WEB
     case glslang::EOpPackSnorm4x8:
         libCall = spv::GLSLstd450PackSnorm4x8;
         break;
@@ -6639,7 +6931,6 @@
     case glslang::EOpUnpackDouble2x32:
         libCall = spv::GLSLstd450UnpackDouble2x32;
         break;
-#endif
 
     case glslang::EOpPackInt2x32:
     case glslang::EOpUnpackInt2x32:
@@ -6694,7 +6985,6 @@
             libCall = spv::GLSLstd450SSign;
         break;
 
-#ifndef GLSLANG_WEB
     case glslang::EOpDPdxFine:
         unaryOp = spv::OpDPdxFine;
         break;
@@ -6866,12 +7156,108 @@
     case glslang::EOpConvUvec2ToAccStruct:
         unaryOp = spv::OpConvertUToAccelerationStructureKHR;
         break;
-#endif
+
+    case glslang::EOpHitObjectIsEmptyNV:
+        unaryOp = spv::OpHitObjectIsEmptyNV;
+        break;
+
+    case glslang::EOpHitObjectIsMissNV:
+        unaryOp = spv::OpHitObjectIsMissNV;
+        break;
+
+    case glslang::EOpHitObjectIsHitNV:
+        unaryOp = spv::OpHitObjectIsHitNV;
+        break;
+
+    case glslang::EOpHitObjectGetObjectRayOriginNV:
+        unaryOp = spv::OpHitObjectGetObjectRayOriginNV;
+        break;
+
+    case glslang::EOpHitObjectGetObjectRayDirectionNV:
+        unaryOp = spv::OpHitObjectGetObjectRayDirectionNV;
+        break;
+
+    case glslang::EOpHitObjectGetWorldRayOriginNV:
+        unaryOp = spv::OpHitObjectGetWorldRayOriginNV;
+        break;
+
+    case glslang::EOpHitObjectGetWorldRayDirectionNV:
+        unaryOp = spv::OpHitObjectGetWorldRayDirectionNV;
+        break;
+
+    case glslang::EOpHitObjectGetObjectToWorldNV:
+        unaryOp = spv::OpHitObjectGetObjectToWorldNV;
+        break;
+
+    case glslang::EOpHitObjectGetWorldToObjectNV:
+        unaryOp = spv::OpHitObjectGetWorldToObjectNV;
+        break;
+
+    case glslang::EOpHitObjectGetRayTMinNV:
+        unaryOp = spv::OpHitObjectGetRayTMinNV;
+        break;
+
+    case glslang::EOpHitObjectGetRayTMaxNV:
+        unaryOp = spv::OpHitObjectGetRayTMaxNV;
+        break;
+
+    case glslang::EOpHitObjectGetPrimitiveIndexNV:
+        unaryOp = spv::OpHitObjectGetPrimitiveIndexNV;
+        break;
+
+    case glslang::EOpHitObjectGetInstanceIdNV:
+        unaryOp = spv::OpHitObjectGetInstanceIdNV;
+        break;
+
+    case glslang::EOpHitObjectGetInstanceCustomIndexNV:
+        unaryOp = spv::OpHitObjectGetInstanceCustomIndexNV;
+        break;
+
+    case glslang::EOpHitObjectGetGeometryIndexNV:
+        unaryOp = spv::OpHitObjectGetGeometryIndexNV;
+        break;
+
+    case glslang::EOpHitObjectGetHitKindNV:
+        unaryOp = spv::OpHitObjectGetHitKindNV;
+        break;
+
+    case glslang::EOpHitObjectGetCurrentTimeNV:
+        unaryOp = spv::OpHitObjectGetCurrentTimeNV;
+        break;
+
+    case glslang::EOpHitObjectGetShaderBindingTableRecordIndexNV:
+        unaryOp = spv::OpHitObjectGetShaderBindingTableRecordIndexNV;
+        break;
+
+    case glslang::EOpHitObjectGetShaderRecordBufferHandleNV:
+        unaryOp = spv::OpHitObjectGetShaderRecordBufferHandleNV;
+        break;
+
+    case glslang::EOpFetchMicroTriangleVertexPositionNV:
+        unaryOp = spv::OpFetchMicroTriangleVertexPositionNV;
+        break;
+
+    case glslang::EOpFetchMicroTriangleVertexBarycentricNV:
+        unaryOp = spv::OpFetchMicroTriangleVertexBarycentricNV;
+        break;
 
     case glslang::EOpCopyObject:
         unaryOp = spv::OpCopyObject;
         break;
 
+    case glslang::EOpDepthAttachmentReadEXT:
+        builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
+        builder.addCapability(spv::CapabilityTileImageDepthReadAccessEXT);
+        unaryOp = spv::OpDepthAttachmentReadEXT;
+        decorations.precision = spv::NoPrecision;
+        break;
+    case glslang::EOpStencilAttachmentReadEXT:
+        builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
+        builder.addCapability(spv::CapabilityTileImageStencilReadAccessEXT);
+        unaryOp = spv::OpStencilAttachmentReadEXT;
+        decorations.precision = spv::DecorationRelaxedPrecision;
+        break;
+
     default:
         return 0;
     }
@@ -6928,7 +7314,9 @@
 // For converting integers where both the bitwidth and the signedness could
 // change, but only do the width change here. The caller is still responsible
 // for the signedness conversion.
-spv::Id TGlslangToSpvTraverser::createIntWidthConversion(glslang::TOperator op, spv::Id operand, int vectorSize)
+// destType is the final type that will be converted to, but this function
+// may only be doing part of that conversion.
+spv::Id TGlslangToSpvTraverser::createIntWidthConversion(glslang::TOperator op, spv::Id operand, int vectorSize, spv::Id destType)
 {
     // Get the result type width, based on the type to convert to.
     int width = 32;
@@ -6999,6 +7387,11 @@
 
     if (vectorSize > 0)
         type = builder.makeVectorType(type, vectorSize);
+    else if (builder.getOpCode(destType) == spv::OpTypeCooperativeMatrixKHR ||
+             builder.getOpCode(destType) == spv::OpTypeCooperativeMatrixNV) {
+
+        type = builder.makeCooperativeMatrixTypeWithSameShape(type, destType);
+    }
 
     return builder.createUnaryOp(convOp, type, operand);
 }
@@ -7030,13 +7423,10 @@
 
     case glslang::EOpConvBoolToInt:
     case glslang::EOpConvBoolToInt64:
-#ifndef GLSLANG_WEB
         if (op == glslang::EOpConvBoolToInt64) {
             zero = builder.makeInt64Constant(0);
             one = builder.makeInt64Constant(1);
-        } else
-#endif
-        {
+        } else {
             zero = builder.makeIntConstant(0);
             one = builder.makeIntConstant(1);
         }
@@ -7046,13 +7436,10 @@
 
     case glslang::EOpConvBoolToUint:
     case glslang::EOpConvBoolToUint64:
-#ifndef GLSLANG_WEB
         if (op == glslang::EOpConvBoolToUint64) {
             zero = builder.makeUint64Constant(0);
             one = builder.makeUint64Constant(1);
-        } else
-#endif
-        {
+        } else {
             zero = builder.makeUintConstant(0);
             one = builder.makeUintConstant(1);
         }
@@ -7115,16 +7502,13 @@
     case glslang::EOpConvInt64ToUint64:
         if (builder.isInSpecConstCodeGenMode()) {
             // Build zero scalar or vector for OpIAdd.
-#ifndef GLSLANG_WEB
             if(op == glslang::EOpConvUint8ToInt8 || op == glslang::EOpConvInt8ToUint8) {
                 zero = builder.makeUint8Constant(0);
             } else if (op == glslang::EOpConvUint16ToInt16 || op == glslang::EOpConvInt16ToUint16) {
                 zero = builder.makeUint16Constant(0);
             } else if (op == glslang::EOpConvUint64ToInt64 || op == glslang::EOpConvInt64ToUint64) {
                 zero = builder.makeUint64Constant(0);
-            } else
-#endif
-            {
+            } else {
                 zero = builder.makeUintConstant(0);
             }
             zero = makeSmearedConstant(zero, vectorSize);
@@ -7151,7 +7535,6 @@
         convOp = spv::OpConvertFToU;
         break;
 
-#ifndef GLSLANG_WEB
     case glslang::EOpConvInt8ToBool:
     case glslang::EOpConvUint8ToBool:
         zero = builder.makeUint8Constant(0);
@@ -7271,7 +7654,7 @@
     case glslang::EOpConvUint64ToInt16:
     case glslang::EOpConvUint64ToInt:
         // OpSConvert/OpUConvert + OpBitCast
-        operand = createIntWidthConversion(op, operand, vectorSize);
+        operand = createIntWidthConversion(op, operand, vectorSize, destType);
 
         if (builder.isInSpecConstCodeGenMode()) {
             // Build zero scalar or vector for OpIAdd.
@@ -7330,7 +7713,6 @@
     case glslang::EOpConvUvec2ToPtr:
         convOp = spv::OpBitcast;
         break;
-#endif
 
     default:
         break;
@@ -8322,7 +8704,6 @@
         }
         break;
 
-#ifndef GLSLANG_WEB
     case glslang::EOpInterpolateAtSample:
         if (typeProxy == glslang::EbtFloat16)
             builder.addExtension(spv::E_SPV_AMD_gpu_shader_half_float);
@@ -8604,10 +8985,157 @@
     case glslang::EOpSetMeshOutputsEXT:
         builder.createNoResultOp(spv::OpSetMeshOutputsEXT, operands);
         return 0;
-    case glslang::EOpCooperativeMatrixMulAdd:
+    case glslang::EOpCooperativeMatrixMulAddNV:
         opCode = spv::OpCooperativeMatrixMulAddNV;
         break;
-#endif // GLSLANG_WEB
+    case glslang::EOpHitObjectTraceRayNV:
+        builder.createNoResultOp(spv::OpHitObjectTraceRayNV, operands);
+        return 0;
+    case glslang::EOpHitObjectTraceRayMotionNV:
+        builder.createNoResultOp(spv::OpHitObjectTraceRayMotionNV, operands);
+        return 0;
+    case glslang::EOpHitObjectRecordHitNV:
+        builder.createNoResultOp(spv::OpHitObjectRecordHitNV, operands);
+        return 0;
+    case glslang::EOpHitObjectRecordHitMotionNV:
+        builder.createNoResultOp(spv::OpHitObjectRecordHitMotionNV, operands);
+        return 0;
+    case glslang::EOpHitObjectRecordHitWithIndexNV:
+        builder.createNoResultOp(spv::OpHitObjectRecordHitWithIndexNV, operands);
+        return 0;
+    case glslang::EOpHitObjectRecordHitWithIndexMotionNV:
+        builder.createNoResultOp(spv::OpHitObjectRecordHitWithIndexMotionNV, operands);
+        return 0;
+    case glslang::EOpHitObjectRecordMissNV:
+        builder.createNoResultOp(spv::OpHitObjectRecordMissNV, operands);
+        return 0;
+    case glslang::EOpHitObjectRecordMissMotionNV:
+        builder.createNoResultOp(spv::OpHitObjectRecordMissMotionNV, operands);
+        return 0;
+    case glslang::EOpHitObjectExecuteShaderNV:
+        builder.createNoResultOp(spv::OpHitObjectExecuteShaderNV, operands);
+        return 0;
+    case glslang::EOpHitObjectIsEmptyNV:
+        typeId = builder.makeBoolType();
+        opCode = spv::OpHitObjectIsEmptyNV;
+        break;
+    case glslang::EOpHitObjectIsMissNV:
+        typeId = builder.makeBoolType();
+        opCode = spv::OpHitObjectIsMissNV;
+        break;
+    case glslang::EOpHitObjectIsHitNV:
+        typeId = builder.makeBoolType();
+        opCode = spv::OpHitObjectIsHitNV;
+        break;
+    case glslang::EOpHitObjectGetRayTMinNV:
+        typeId = builder.makeFloatType(32);
+        opCode = spv::OpHitObjectGetRayTMinNV;
+        break;
+    case glslang::EOpHitObjectGetRayTMaxNV:
+        typeId = builder.makeFloatType(32);
+        opCode = spv::OpHitObjectGetRayTMaxNV;
+        break;
+    case glslang::EOpHitObjectGetObjectRayOriginNV:
+        typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
+        opCode = spv::OpHitObjectGetObjectRayOriginNV;
+        break;
+    case glslang::EOpHitObjectGetObjectRayDirectionNV:
+        typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
+        opCode = spv::OpHitObjectGetObjectRayDirectionNV;
+        break;
+    case glslang::EOpHitObjectGetWorldRayOriginNV:
+        typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
+        opCode = spv::OpHitObjectGetWorldRayOriginNV;
+        break;
+    case glslang::EOpHitObjectGetWorldRayDirectionNV:
+        typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
+        opCode = spv::OpHitObjectGetWorldRayDirectionNV;
+        break;
+    case glslang::EOpHitObjectGetWorldToObjectNV:
+        typeId = builder.makeMatrixType(builder.makeFloatType(32), 4, 3);
+        opCode = spv::OpHitObjectGetWorldToObjectNV;
+        break;
+    case glslang::EOpHitObjectGetObjectToWorldNV:
+        typeId = builder.makeMatrixType(builder.makeFloatType(32), 4, 3);
+        opCode = spv::OpHitObjectGetObjectToWorldNV;
+        break;
+    case glslang::EOpHitObjectGetInstanceCustomIndexNV:
+        typeId = builder.makeIntegerType(32, 1);
+        opCode = spv::OpHitObjectGetInstanceCustomIndexNV;
+        break;
+    case glslang::EOpHitObjectGetInstanceIdNV:
+        typeId = builder.makeIntegerType(32, 1);
+        opCode = spv::OpHitObjectGetInstanceIdNV;
+        break;
+    case glslang::EOpHitObjectGetGeometryIndexNV:
+        typeId = builder.makeIntegerType(32, 1);
+        opCode = spv::OpHitObjectGetGeometryIndexNV;
+        break;
+    case glslang::EOpHitObjectGetPrimitiveIndexNV:
+        typeId = builder.makeIntegerType(32, 1);
+        opCode = spv::OpHitObjectGetPrimitiveIndexNV;
+        break;
+    case glslang::EOpHitObjectGetHitKindNV:
+        typeId = builder.makeIntegerType(32, 0);
+        opCode = spv::OpHitObjectGetHitKindNV;
+        break;
+    case glslang::EOpHitObjectGetCurrentTimeNV:
+        typeId = builder.makeFloatType(32);
+        opCode = spv::OpHitObjectGetCurrentTimeNV;
+        break;
+    case glslang::EOpHitObjectGetShaderBindingTableRecordIndexNV:
+        typeId = builder.makeIntegerType(32, 0);
+        opCode = spv::OpHitObjectGetShaderBindingTableRecordIndexNV;
+        return 0;
+    case glslang::EOpHitObjectGetAttributesNV:
+        builder.createNoResultOp(spv::OpHitObjectGetAttributesNV, operands);
+        return 0;
+    case glslang::EOpHitObjectGetShaderRecordBufferHandleNV:
+        typeId = builder.makeVectorType(builder.makeUintType(32), 2);
+        opCode = spv::OpHitObjectGetShaderRecordBufferHandleNV;
+        break;
+    case glslang::EOpReorderThreadNV: {
+        if (operands.size() == 2) {
+            builder.createNoResultOp(spv::OpReorderThreadWithHintNV, operands);
+        } else {
+            builder.createNoResultOp(spv::OpReorderThreadWithHitObjectNV, operands);
+        }
+        return 0;
+
+    }
+
+    case glslang::EOpImageSampleWeightedQCOM:
+        typeId = builder.makeVectorType(builder.makeFloatType(32), 4);
+        opCode = spv::OpImageSampleWeightedQCOM;
+        addImageProcessingQCOMDecoration(operands[2], spv::DecorationWeightTextureQCOM);
+        break;
+    case glslang::EOpImageBoxFilterQCOM:
+        typeId = builder.makeVectorType(builder.makeFloatType(32), 4);
+        opCode = spv::OpImageBoxFilterQCOM;
+        break;
+    case glslang::EOpImageBlockMatchSADQCOM:
+        typeId = builder.makeVectorType(builder.makeFloatType(32), 4);
+        opCode = spv::OpImageBlockMatchSADQCOM;
+        addImageProcessingQCOMDecoration(operands[0], spv::DecorationBlockMatchTextureQCOM);
+        addImageProcessingQCOMDecoration(operands[2], spv::DecorationBlockMatchTextureQCOM);
+        break;
+    case glslang::EOpImageBlockMatchSSDQCOM:
+        typeId = builder.makeVectorType(builder.makeFloatType(32), 4);
+        opCode = spv::OpImageBlockMatchSSDQCOM;
+        addImageProcessingQCOMDecoration(operands[0], spv::DecorationBlockMatchTextureQCOM);
+        addImageProcessingQCOMDecoration(operands[2], spv::DecorationBlockMatchTextureQCOM);
+        break;
+
+    case glslang::EOpFetchMicroTriangleVertexBarycentricNV:
+        typeId = builder.makeVectorType(builder.makeFloatType(32), 2);
+        opCode = spv::OpFetchMicroTriangleVertexBarycentricNV;
+        break;
+
+    case glslang::EOpFetchMicroTriangleVertexPositionNV:
+        typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
+        opCode = spv::OpFetchMicroTriangleVertexPositionNV;
+        break;
+
     default:
         return 0;
     }
@@ -8651,7 +9179,6 @@
         }
     }
 
-#ifndef GLSLANG_WEB
     // Decode the return types that were structures
     switch (op) {
     case glslang::EOpAddCarry:
@@ -8681,7 +9208,6 @@
     default:
         break;
     }
-#endif
 
     return builder.setPrecision(id, precision);
 }
@@ -8726,7 +9252,6 @@
         builder.createMemoryBarrier(spv::ScopeWorkgroup, spv::MemorySemanticsAllMemory |
                                                          spv::MemorySemanticsAcquireReleaseMask);
         return 0;
-#ifndef GLSLANG_WEB
     case glslang::EOpMemoryBarrierAtomicCounter:
         builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsAtomicCounterMemoryMask |
                                                         spv::MemorySemanticsAcquireReleaseMask);
@@ -8845,7 +9370,30 @@
         builder.addCapability(spv::CapabilityShaderClockKHR);
         return builder.createOp(spv::OpReadClockKHR, typeId, args);
     }
-#endif
+    case glslang::EOpStencilAttachmentReadEXT:
+    case glslang::EOpDepthAttachmentReadEXT:
+    {
+        builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
+
+        spv::Decoration precision;
+        spv::Op spv_op;
+        if (op == glslang::EOpStencilAttachmentReadEXT)
+        {
+            precision = spv::DecorationRelaxedPrecision;
+            spv_op = spv::OpStencilAttachmentReadEXT;
+            builder.addCapability(spv::CapabilityTileImageStencilReadAccessEXT);
+        }
+        else
+        {
+            precision = spv::NoPrecision;
+            spv_op = spv::OpDepthAttachmentReadEXT;
+            builder.addCapability(spv::CapabilityTileImageDepthReadAccessEXT);
+        }
+
+        std::vector<spv::Id> args; // Dummy args
+        spv::Id result = builder.createOp(spv_op, typeId, args);
+        return builder.setPrecision(result, precision);
+    }
     default:
         break;
     }
@@ -8901,13 +9449,11 @@
         builder.addDecoration(id, TranslatePrecisionDecoration(symbol->getType()));
         builder.addDecoration(id, TranslateInterpolationDecoration(symbol->getType().getQualifier()));
         builder.addDecoration(id, TranslateAuxiliaryStorageDecoration(symbol->getType().getQualifier()));
-#ifndef GLSLANG_WEB
         addMeshNVDecoration(id, /*member*/ -1, symbol->getType().getQualifier());
         if (symbol->getQualifier().hasComponent())
             builder.addDecoration(id, spv::DecorationComponent, symbol->getQualifier().layoutComponent);
         if (symbol->getQualifier().hasIndex())
             builder.addDecoration(id, spv::DecorationIndex, symbol->getQualifier().layoutIndex);
-#endif
         if (symbol->getType().getQualifier().hasSpecConstantId())
             builder.addDecoration(id, spv::DecorationSpecId, symbol->getType().getQualifier().layoutSpecConstantId);
         // atomic counters use this:
@@ -8916,13 +9462,17 @@
     }
 
     if (symbol->getQualifier().hasLocation()) {
-        if (!(glslangIntermediate->isRayTracingStage() && glslangIntermediate->IsRequestedExtension(glslang::E_GL_EXT_ray_tracing)
+        if (!(glslangIntermediate->isRayTracingStage() &&
+              (glslangIntermediate->IsRequestedExtension(glslang::E_GL_EXT_ray_tracing) ||
+               glslangIntermediate->IsRequestedExtension(glslang::E_GL_NV_shader_invocation_reorder))
               && (builder.getStorageClass(id) == spv::StorageClassRayPayloadKHR ||
                   builder.getStorageClass(id) == spv::StorageClassIncomingRayPayloadKHR ||
                   builder.getStorageClass(id) == spv::StorageClassCallableDataKHR ||
-                  builder.getStorageClass(id) == spv::StorageClassIncomingCallableDataKHR))) {
-            // Location values are used to link TraceRayKHR and ExecuteCallableKHR to corresponding variables
-            // but are not valid in SPIRV since they are supported only for Input/Output Storage classes.
+                  builder.getStorageClass(id) == spv::StorageClassIncomingCallableDataKHR ||
+                  builder.getStorageClass(id) == spv::StorageClassHitObjectAttributeNV))) {
+            // Location values are used to link TraceRayKHR/ExecuteCallableKHR/HitObjectGetAttributesNV
+            // to corresponding variables but are not valid in SPIRV since they are supported only
+            // for Input/Output Storage classes.
             builder.addDecoration(id, spv::DecorationLocation, symbol->getQualifier().layoutLocation);
         }
     }
@@ -8968,11 +9518,11 @@
 
     // Add volatile decoration to HelperInvocation for spirv1.6 and beyond
     if (builtIn == spv::BuiltInHelperInvocation &&
+        !glslangIntermediate->usingVulkanMemoryModel() &&
         glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6) {
         builder.addDecoration(id, spv::DecorationVolatile);
     }
 
-#ifndef GLSLANG_WEB
     // Subgroup builtins which have input storage class are volatile for ray tracing stages.
     if (symbol->getType().isImage() || symbol->getQualifier().isPipeInput()) {
         std::vector<spv::Decoration> memory;
@@ -9060,10 +9610,10 @@
             std::vector<spv::Id> operandIds;
             assert(!decorateId.second.empty());
             for (auto extraOperand : decorateId.second) {
-                if (extraOperand->getQualifier().isSpecConstant())
-                    operandIds.push_back(getSymbolId(extraOperand->getAsSymbolNode()));
-                else
+                if (extraOperand->getQualifier().isFrontEndConstant())
                     operandIds.push_back(createSpvConstant(*extraOperand));
+                else
+                    operandIds.push_back(getSymbolId(extraOperand->getAsSymbolNode()));
             }
             builder.addDecorationId(id, static_cast<spv::Decoration>(decorateId.first), operandIds);
         }
@@ -9079,12 +9629,10 @@
             builder.addDecoration(id, static_cast<spv::Decoration>(decorateString.first), strings);
         }
     }
-#endif
 
     return id;
 }
 
-#ifndef GLSLANG_WEB
 // add per-primitive, per-view. per-task decorations to a struct member (member >= 0) or an object
 void TGlslangToSpvTraverser::addMeshNVDecoration(spv::Id id, int member, const glslang::TQualifier& qualifier)
 {
@@ -9131,7 +9679,20 @@
             builder.addDecoration(id, spv::DecorationPerTaskNV);
     }
 }
-#endif
+
+void TGlslangToSpvTraverser::addImageProcessingQCOMDecoration(spv::Id id, spv::Decoration decor)
+{
+  spv::Op opc = builder.getOpCode(id);
+  if (opc == spv::OpSampledImage) {
+    id  = builder.getIdOperand(id, 0);
+    opc = builder.getOpCode(id);
+  }
+
+  if (opc == spv::OpLoad) {
+    spv::Id texid = builder.getIdOperand(id, 0);
+    builder.addDecoration(texid, decor);
+  }
+}
 
 // Make a full tree of instructions to build a SPIR-V specialization constant,
 // or regular constant if possible.
@@ -9259,7 +9820,6 @@
             case glslang::EbtBool:
                 spvConsts.push_back(builder.makeBoolConstant(zero ? false : consts[nextConst].getBConst()));
                 break;
-#ifndef GLSLANG_WEB
             case glslang::EbtInt8:
                 builder.addCapability(spv::CapabilityInt8);
                 spvConsts.push_back(builder.makeInt8Constant(zero ? 0 : consts[nextConst].getI8Const()));
@@ -9289,7 +9849,6 @@
                 builder.addCapability(spv::CapabilityFloat16);
                 spvConsts.push_back(builder.makeFloat16Constant(zero ? 0.0F : (float)consts[nextConst].getDConst()));
                 break;
-#endif
             default:
                 assert(0);
                 break;
@@ -9313,7 +9872,6 @@
         case glslang::EbtBool:
             scalar = builder.makeBoolConstant(zero ? false : consts[nextConst].getBConst(), specConstant);
             break;
-#ifndef GLSLANG_WEB
         case glslang::EbtInt8:
             builder.addCapability(spv::CapabilityInt8);
             scalar = builder.makeInt8Constant(zero ? 0 : consts[nextConst].getI8Const(), specConstant);
@@ -9347,7 +9905,6 @@
             scalar = builder.makeUint64Constant(zero ? 0 : consts[nextConst].getU64Const(), specConstant);
             scalar = builder.createUnaryOp(spv::OpBitcast, typeId, scalar);
             break;
-#endif
         case glslang::EbtString:
             scalar = builder.getStringId(consts[nextConst].getSConst()->c_str());
             break;
@@ -9495,7 +10052,6 @@
     return builder.createOp(spv::OpPhi, boolTypeId, phiOperands);
 }
 
-#ifndef GLSLANG_WEB
 // Return type Id of the imported set of extended instructions corresponds to the name.
 // Import this set if it has not been imported yet.
 spv::Id TGlslangToSpvTraverser::getExtBuiltins(const char* name)
@@ -9509,7 +10065,6 @@
         return extBuiltins;
     }
 }
-#endif
 
 };  // end anonymous namespace
 
@@ -9543,27 +10098,31 @@
 }
 
 // Write SPIR-V out to a binary file
-void OutputSpvBin(const std::vector<unsigned int>& spirv, const char* baseName)
+bool OutputSpvBin(const std::vector<unsigned int>& spirv, const char* baseName)
 {
     std::ofstream out;
     out.open(baseName, std::ios::binary | std::ios::out);
-    if (out.fail())
+    if (out.fail()) {
         printf("ERROR: Failed to open file: %s\n", baseName);
+        return false;
+    }
     for (int i = 0; i < (int)spirv.size(); ++i) {
         unsigned int word = spirv[i];
         out.write((const char*)&word, 4);
     }
     out.close();
+    return true;
 }
 
 // Write SPIR-V out to a text file with 32-bit hexadecimal words
-void OutputSpvHex(const std::vector<unsigned int>& spirv, const char* baseName, const char* varName)
+bool OutputSpvHex(const std::vector<unsigned int>& spirv, const char* baseName, const char* varName)
 {
-#if !defined(GLSLANG_WEB) && !defined(GLSLANG_ANGLE)
     std::ofstream out;
     out.open(baseName, std::ios::binary | std::ios::out);
-    if (out.fail())
+    if (out.fail()) {
         printf("ERROR: Failed to open file: %s\n", baseName);
+        return false;
+    }
     out << "\t// " <<
         GetSpirvGeneratorVersion() <<
         GLSLANG_VERSION_MAJOR << "." << GLSLANG_VERSION_MINOR << "." << GLSLANG_VERSION_PATCH <<
@@ -9589,7 +10148,7 @@
         out << std::endl;
     }
     out.close();
-#endif
+    return true;
 }
 
 //
@@ -9606,7 +10165,7 @@
 {
     TIntermNode* root = intermediate.getTreeRoot();
 
-    if (root == 0)
+    if (root == nullptr)
         return;
 
     SpvOptions defaultOptions;
@@ -9617,7 +10176,7 @@
 
     TGlslangToSpvTraverser it(intermediate.getSpv().spv, &intermediate, logger, *options);
     root->traverse(&it);
-    it.finishSpv();
+    it.finishSpv(options->compileOnly);
     it.dumpSpv(spirv);
 
 #if ENABLE_OPT
diff --git a/SPIRV/GlslangToSpv.h b/SPIRV/GlslangToSpv.h
index 3907be4..b9736d7 100644
--- a/SPIRV/GlslangToSpv.h
+++ b/SPIRV/GlslangToSpv.h
@@ -55,7 +55,7 @@
                   SpvOptions* options = nullptr);
 void GlslangToSpv(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv,
                   spv::SpvBuildLogger* logger, SpvOptions* options = nullptr);
-void OutputSpvBin(const std::vector<unsigned int>& spirv, const char* baseName);
-void OutputSpvHex(const std::vector<unsigned int>& spirv, const char* baseName, const char* varName);
+bool OutputSpvBin(const std::vector<unsigned int>& spirv, const char* baseName);
+bool OutputSpvHex(const std::vector<unsigned int>& spirv, const char* baseName, const char* varName);
 
 }
diff --git a/SPIRV/Logger.cpp b/SPIRV/Logger.cpp
index cdc8469..48bd4e3 100644
--- a/SPIRV/Logger.cpp
+++ b/SPIRV/Logger.cpp
@@ -32,8 +32,6 @@
 // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 // POSSIBILITY OF SUCH DAMAGE.
 
-#ifndef GLSLANG_WEB
-
 #include "Logger.h"
 
 #include <algorithm>
@@ -68,5 +66,3 @@
 }
 
 } // end spv namespace
-
-#endif
diff --git a/SPIRV/Logger.h b/SPIRV/Logger.h
index 411367c..2e4ddaf 100644
--- a/SPIRV/Logger.h
+++ b/SPIRV/Logger.h
@@ -46,14 +46,6 @@
 public:
     SpvBuildLogger() {}
 
-#ifdef GLSLANG_WEB
-    void tbdFunctionality(const std::string& f) { }
-    void missingFunctionality(const std::string& f) { }
-    void warning(const std::string& w) { }
-    void error(const std::string& e) { errors.push_back(e); }
-    std::string getAllMessages() { return ""; }
-#else
-
     // Registers a TBD functionality.
     void tbdFunctionality(const std::string& f);
     // Registers a missing functionality.
@@ -67,7 +59,6 @@
     // Returns all messages accumulated in the order of:
     // TBD functionalities, missing functionalities, warnings, errors.
     std::string getAllMessages() const;
-#endif
 
 private:
     SpvBuildLogger(const SpvBuildLogger&);
diff --git a/SPIRV/NonSemanticDebugPrintf.h b/SPIRV/NonSemanticDebugPrintf.h
index 83796d7..3ca7247 100644
--- a/SPIRV/NonSemanticDebugPrintf.h
+++ b/SPIRV/NonSemanticDebugPrintf.h
@@ -1,5 +1,5 @@
 // Copyright (c) 2020 The Khronos Group Inc.
-// 
+//
 // Permission is hereby granted, free of charge, to any person obtaining a
 // copy of this software and/or associated documentation files (the
 // "Materials"), to deal in the Materials without restriction, including
@@ -7,15 +7,15 @@
 // distribute, sublicense, and/or sell copies of the Materials, and to
 // permit persons to whom the Materials are furnished to do so, subject to
 // the following conditions:
-// 
+//
 // The above copyright notice and this permission notice shall be included
 // in all copies or substantial portions of the Materials.
-// 
+//
 // MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
 // KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
 // SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
 //    https://www.khronos.org/registry/
-// 
+//
 // THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
@@ -23,7 +23,7 @@
 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 // MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
-// 
+//
 
 #ifndef SPIRV_UNIFIED1_NonSemanticDebugPrintf_H_
 #define SPIRV_UNIFIED1_NonSemanticDebugPrintf_H_
diff --git a/SPIRV/NonSemanticShaderDebugInfo100.h b/SPIRV/NonSemanticShaderDebugInfo100.h
index c52f32f..f74abcb 100644
--- a/SPIRV/NonSemanticShaderDebugInfo100.h
+++ b/SPIRV/NonSemanticShaderDebugInfo100.h
@@ -1,19 +1,19 @@
 // Copyright (c) 2018 The Khronos Group Inc.
-// 
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and/or associated documentation files (the "Materials"),
 // to deal in the Materials without restriction, including without limitation
 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
 // and/or sell copies of the Materials, and to permit persons to whom the
 // Materials are furnished to do so, subject to the following conditions:
-// 
+//
 // The above copyright notice and this permission notice shall be included in
 // all copies or substantial portions of the Materials.
-// 
+//
 // MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
 // STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
-// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
-// 
+// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
+//
 // THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
diff --git a/SPIRV/SPVRemapper.cpp b/SPIRV/SPVRemapper.cpp
index 6aca8cb..f8f50a9 100644
--- a/SPIRV/SPVRemapper.cpp
+++ b/SPIRV/SPVRemapper.cpp
@@ -36,10 +36,6 @@
 #include "SPVRemapper.h"
 #include "doc.h"
 
-#if !defined (use_cpp11)
-// ... not supported before C++11
-#else // defined (use_cpp11)
-
 #include <algorithm>
 #include <cassert>
 #include "../glslang/Include/Common.h"
@@ -684,6 +680,7 @@
             case spv::OperandKernelEnqueueFlags:
             case spv::OperandKernelProfilingInfo:
             case spv::OperandCapability:
+            case spv::OperandCooperativeMatrixOperands:
                 ++word;
                 break;
 
@@ -1528,5 +1525,3 @@
 
 } // namespace SPV
 
-#endif // defined (use_cpp11)
-
diff --git a/SPIRV/SPVRemapper.h b/SPIRV/SPVRemapper.h
index d216946..42b0168 100644
--- a/SPIRV/SPVRemapper.h
+++ b/SPIRV/SPVRemapper.h
@@ -43,12 +43,6 @@
 
 namespace spv {
 
-// MSVC defines __cplusplus as an older value, even when it supports almost all of 11.
-// We handle that here by making our own symbol.
-#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1700)
-#   define use_cpp11 1
-#endif
-
 class spirvbin_base_t
 {
 public:
@@ -74,27 +68,6 @@
 
 } // namespace SPV
 
-#if !defined (use_cpp11)
-#include <cstdio>
-#include <cstdint>
-
-namespace spv {
-class spirvbin_t : public spirvbin_base_t
-{
-public:
-    spirvbin_t(int /*verbose = 0*/) { }
-
-    void remap(std::vector<std::uint32_t>& /*spv*/, unsigned int /*opts = 0*/)
-    {
-        printf("Tool not compiled for C++11, which is required for SPIR-V remapping.\n");
-        exit(5);
-    }
-};
-
-} // namespace SPV
-
-#else // defined (use_cpp11)
-
 #include <functional>
 #include <cstdint>
 #include <unordered_map>
@@ -308,5 +281,4 @@
 
 } // namespace SPV
 
-#endif // defined (use_cpp11)
 #endif // SPIRVREMAPPER_H
diff --git a/SPIRV/SpvBuilder.cpp b/SPIRV/SpvBuilder.cpp
index 7c5ea87..d42f728 100644
--- a/SPIRV/SpvBuilder.cpp
+++ b/SPIRV/SpvBuilder.cpp
@@ -46,10 +46,7 @@
 #include <algorithm>
 
 #include "SpvBuilder.h"
-
-#ifndef GLSLANG_WEB
 #include "hex_float.h"
-#endif
 
 #ifndef _WIN32
     #include <cstdio>
@@ -71,9 +68,9 @@
     addressModel(AddressingModelLogical),
     memoryModel(MemoryModelGLSL450),
     builderNumber(magicNumber),
-    buildPoint(0),
+    buildPoint(nullptr),
     uniqueId(0),
-    entryPointFunction(0),
+    entryPointFunction(nullptr),
     generatingOpCodeForSpecConst(false),
     logger(buildLogger)
 {
@@ -144,6 +141,7 @@
 
 void Builder::addDebugScopeAndLine(Id fileName, int lineNum, int column)
 {
+    assert(!currentDebugScopeId.empty());
     if (currentDebugScopeId.top() != lastDebugScopeId) {
         spv::Id resultId = getUniqueId();
         Instruction* scopeInst = new Instruction(resultId, makeVoidType(), OpExtInst);
@@ -282,11 +280,6 @@
 
 Id Builder::makeIntegerType(int width, bool hasSign)
 {
-#ifdef GLSLANG_WEB
-    assert(width == 32);
-    width = 32;
-#endif
-
     // try to find it
     Instruction* type;
     for (int t = 0; t < (int)groupedTypes[OpTypeInt].size(); ++t) {
@@ -328,11 +321,6 @@
 
 Id Builder::makeFloatType(int width)
 {
-#ifdef GLSLANG_WEB
-    assert(width == 32);
-    width = 32;
-#endif
-
     // try to find it
     Instruction* type;
     for (int t = 0; t < (int)groupedTypes[OpTypeFloat].size(); ++t) {
@@ -480,15 +468,41 @@
     return type->getResultId();
 }
 
-Id Builder::makeCooperativeMatrixType(Id component, Id scope, Id rows, Id cols)
+Id Builder::makeCooperativeMatrixTypeKHR(Id component, Id scope, Id rows, Id cols, Id use)
+{
+    // try to find it
+    Instruction* type;
+    for (int t = 0; t < (int)groupedTypes[OpTypeCooperativeMatrixKHR].size(); ++t) {
+        type = groupedTypes[OpTypeCooperativeMatrixKHR][t];
+        if (type->getIdOperand(0) == component &&
+            type->getIdOperand(1) == scope &&
+            type->getIdOperand(2) == rows &&
+            type->getIdOperand(3) == cols &&
+            type->getIdOperand(4) == use)
+            return type->getResultId();
+    }
+
+    // not found, make it
+    type = new Instruction(getUniqueId(), NoType, OpTypeCooperativeMatrixKHR);
+    type->addIdOperand(component);
+    type->addIdOperand(scope);
+    type->addIdOperand(rows);
+    type->addIdOperand(cols);
+    type->addIdOperand(use);
+    groupedTypes[OpTypeCooperativeMatrixKHR].push_back(type);
+    constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+    module.mapInstruction(type);
+
+    return type->getResultId();
+}
+
+Id Builder::makeCooperativeMatrixTypeNV(Id component, Id scope, Id rows, Id cols)
 {
     // try to find it
     Instruction* type;
     for (int t = 0; t < (int)groupedTypes[OpTypeCooperativeMatrixNV].size(); ++t) {
         type = groupedTypes[OpTypeCooperativeMatrixNV][t];
-        if (type->getIdOperand(0) == component &&
-            type->getIdOperand(1) == scope &&
-            type->getIdOperand(2) == rows &&
+        if (type->getIdOperand(0) == component && type->getIdOperand(1) == scope && type->getIdOperand(2) == rows &&
             type->getIdOperand(3) == cols)
             return type->getResultId();
     }
@@ -506,6 +520,17 @@
     return type->getResultId();
 }
 
+Id Builder::makeCooperativeMatrixTypeWithSameShape(Id component, Id otherType)
+{
+    Instruction* instr = module.getInstruction(otherType);
+    if (instr->getOpCode() == OpTypeCooperativeMatrixNV) {
+        return makeCooperativeMatrixTypeNV(component, instr->getIdOperand(1), instr->getIdOperand(2), instr->getIdOperand(3));
+    } else {
+        assert(instr->getOpCode() == OpTypeCooperativeMatrixKHR);
+        return makeCooperativeMatrixTypeKHR(component, instr->getIdOperand(1), instr->getIdOperand(2), instr->getIdOperand(3), instr->getIdOperand(4));
+    }
+}
+
 Id Builder::makeGenericType(spv::Op opcode, std::vector<spv::IdImmediate>& operands)
 {
     // try to find it
@@ -650,8 +675,12 @@
     type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100FlagIsPublic));
     type->addIdOperand(debugId[returnType]);
     for (auto const paramType : paramTypes) {
-        assert(isPointerType(paramType) || isArrayType(paramType));
-        type->addIdOperand(debugId[getContainedTypeId(paramType)]);
+        if (isPointerType(paramType) || isArrayType(paramType)) {
+            type->addIdOperand(debugId[getContainedTypeId(paramType)]);
+        }
+        else {
+            type->addIdOperand(debugId[paramType]);
+        }
     }
     constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
     module.mapInstruction(type);
@@ -691,7 +720,6 @@
     constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
     module.mapInstruction(type);
 
-#ifndef GLSLANG_WEB
     // deal with capabilities
     switch (dim) {
     case DimBuffer:
@@ -737,7 +765,6 @@
                 addCapability(CapabilityImageMSArray);
         }
     }
-#endif
 
     if (emitNonSemanticShaderDebugInfo)
     {
@@ -832,11 +859,19 @@
 
 Id Builder::makeIntegerDebugType(int const width, bool const hasSign)
 {
+    const char* typeName = nullptr;
+    switch (width) {
+        case 8:  typeName = hasSign ? "int8_t" : "uint8_t"; break;
+        case 16: typeName = hasSign ? "int16_t" : "uint16_t"; break;
+        case 64: typeName = hasSign ? "int64_t" : "uint64_t"; break;
+        default: typeName = hasSign ? "int" : "uint";
+    }
+    auto nameId = getStringId(typeName);
     // try to find it
     Instruction* type;
     for (int t = 0; t < (int)groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeBasic].size(); ++t) {
         type = groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeBasic][t];
-        if (type->getIdOperand(0) == (hasSign ? getStringId("int") : getStringId("uint")) &&
+        if (type->getIdOperand(0) == nameId &&
             type->getIdOperand(1) == static_cast<unsigned int>(width) &&
             type->getIdOperand(2) == (hasSign ? NonSemanticShaderDebugInfo100Signed : NonSemanticShaderDebugInfo100Unsigned))
             return type->getResultId();
@@ -846,11 +881,7 @@
     type = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
     type->addIdOperand(nonSemanticShaderDebugInfo);
     type->addImmediateOperand(NonSemanticShaderDebugInfo100DebugTypeBasic);
-    if(hasSign == true) {
-        type->addIdOperand(getStringId("int")); // name id
-    } else {
-        type->addIdOperand(getStringId("uint")); // name id
-    }
+    type->addIdOperand(nameId); // name id
     type->addIdOperand(makeUintConstant(width)); // size id
     if(hasSign == true) {
         type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100Signed)); // encoding id
@@ -868,11 +899,18 @@
 
 Id Builder::makeFloatDebugType(int const width)
 {
+    const char* typeName = nullptr;
+    switch (width) {
+        case 16: typeName = "float16_t"; break;
+        case 64: typeName = "double"; break;
+        default: typeName = "float"; break;
+    }
+    auto nameId = getStringId(typeName);
     // try to find it
     Instruction* type;
     for (int t = 0; t < (int)groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeBasic].size(); ++t) {
         type = groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeBasic][t];
-        if (type->getIdOperand(0) == getStringId("float") &&
+        if (type->getIdOperand(0) == nameId &&
             type->getIdOperand(1) == static_cast<unsigned int>(width) &&
             type->getIdOperand(2) == NonSemanticShaderDebugInfo100Float)
             return type->getResultId();
@@ -882,7 +920,7 @@
     type = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
     type->addIdOperand(nonSemanticShaderDebugInfo);
     type->addImmediateOperand(NonSemanticShaderDebugInfo100DebugTypeBasic);
-    type->addIdOperand(getStringId("float")); // name id
+    type->addIdOperand(nameId); // name id
     type->addIdOperand(makeUintConstant(width)); // size id
     type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100Float)); // encoding id
     type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100None)); // flags id
@@ -929,7 +967,7 @@
 
 Id Builder::makeVectorDebugType(Id const baseType, int const componentCount)
 {
-    return makeSequentialDebugType(baseType, makeUintConstant(componentCount), NonSemanticShaderDebugInfo100DebugTypeVector);;
+    return makeSequentialDebugType(baseType, makeUintConstant(componentCount), NonSemanticShaderDebugInfo100DebugTypeVector);
 }
 
 Id Builder::makeMatrixDebugType(Id const vectorType, int const vectorCount, bool columnMajor)
@@ -991,7 +1029,10 @@
     for(auto const memberType : memberTypes) {
         assert(debugTypeLocs.find(memberType) != debugTypeLocs.end());
 
-        memberDebugTypes.emplace_back(makeMemberDebugType(memberType, debugTypeLocs[memberType]));
+        // There _should_ be debug types for all the member types but currently buffer references
+        // do not have member debug info generated.
+        if (debugId[memberType])
+            memberDebugTypes.emplace_back(makeMemberDebugType(memberType, debugTypeLocs[memberType]));
 
         // TODO: Need to rethink this method of passing location information.
         // debugTypeLocs.erase(memberType);
@@ -1067,6 +1108,12 @@
     constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(sourceInst));
     module.mapInstruction(sourceInst);
     nonSemanticShaderCompilationUnitId = resultId;
+
+    // We can reasonably assume that makeDebugCompilationUnit will be called before any of
+    // debug-scope stack. Function scopes and lexical scopes will occur afterward.
+    assert(currentDebugScopeId.empty());
+    currentDebugScopeId.push(nonSemanticShaderCompilationUnitId);
+
     return resultId;
 }
 
@@ -1096,6 +1143,8 @@
 Id Builder::createDebugLocalVariable(Id type, char const*const name, size_t const argNumber)
 {
     assert(name != nullptr);
+    assert(!currentDebugScopeId.empty());
+
     Instruction* inst = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
     inst->addIdOperand(nonSemanticShaderDebugInfo);
     inst->addImmediateOperand(NonSemanticShaderDebugInfo100DebugLocalVariable);
@@ -1146,7 +1195,6 @@
     return inst->getResultId();
 }
 
-#ifndef GLSLANG_WEB
 Id Builder::makeAccelerationStructureType()
 {
     Instruction *type;
@@ -1176,7 +1224,21 @@
 
     return type->getResultId();
 }
-#endif
+
+Id Builder::makeHitObjectNVType()
+{
+    Instruction *type;
+    if (groupedTypes[OpTypeHitObjectNV].size() == 0) {
+        type = new Instruction(getUniqueId(), NoType, OpTypeHitObjectNV);
+        groupedTypes[OpTypeHitObjectNV].push_back(type);
+        constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+        module.mapInstruction(type);
+    } else {
+        type = groupedTypes[OpTypeHitObjectNV].back();
+    }
+
+    return type->getResultId();
+}
 
 Id Builder::getDerefTypeId(Id resultId) const
 {
@@ -1226,6 +1288,7 @@
     }
     case OpTypeStruct:
         return instr->getNumOperands();
+    case OpTypeCooperativeMatrixKHR:
     case OpTypeCooperativeMatrixNV:
         // has only one constituent when used with OpCompositeConstruct.
         return 1;
@@ -1275,6 +1338,7 @@
     case OpTypeMatrix:
     case OpTypeArray:
     case OpTypeRuntimeArray:
+    case OpTypeCooperativeMatrixKHR:
     case OpTypeCooperativeMatrixNV:
         return instr->getIdOperand(0);
     case OpTypePointer:
@@ -1345,7 +1409,7 @@
 }
 
 // return true if the type is a pointer to PhysicalStorageBufferEXT or an
-// array of such pointers. These require restrict/aliased decorations.
+// contains such a pointer. These require restrict/aliased decorations.
 bool Builder::containsPhysicalStorageBufferOrArray(Id typeId) const
 {
     const Instruction& instr = *module.getInstruction(typeId);
@@ -1357,6 +1421,12 @@
         return getTypeStorageClass(typeId) == StorageClassPhysicalStorageBufferEXT;
     case OpTypeArray:
         return containsPhysicalStorageBufferOrArray(getContainedTypeId(typeId));
+    case OpTypeStruct:
+        for (int m = 0; m < instr.getNumOperands(); ++m) {
+            if (containsPhysicalStorageBufferOrArray(instr.getIdOperand(m)))
+                return true;
+        }
+        return false;
     default:
         return false;
     }
@@ -1570,10 +1640,6 @@
 
 Id Builder::makeDoubleConstant(double d, bool specConstant)
 {
-#ifdef GLSLANG_WEB
-    assert(0);
-    return NoResult;
-#else
     Op opcode = specConstant ? OpSpecConstant : OpConstant;
     Id typeId = makeFloatType(64);
     union { double db; unsigned long long ull; } u;
@@ -1598,15 +1664,10 @@
     module.mapInstruction(c);
 
     return c->getResultId();
-#endif
 }
 
 Id Builder::makeFloat16Constant(float f16, bool specConstant)
 {
-#ifdef GLSLANG_WEB
-    assert(0);
-    return NoResult;
-#else
     Op opcode = specConstant ? OpSpecConstant : OpConstant;
     Id typeId = makeFloatType(16);
 
@@ -1631,17 +1692,11 @@
     module.mapInstruction(c);
 
     return c->getResultId();
-#endif
 }
 
 Id Builder::makeFpConstant(Id type, double d, bool specConstant)
 {
-#ifdef GLSLANG_WEB
-    const int width = 32;
-    assert(width == getScalarTypeWidth(type));
-#else
     const int width = getScalarTypeWidth(type);
-#endif
 
     assert(isFloatType(type));
 
@@ -1675,7 +1730,7 @@
 
 Id Builder::findCompositeConstant(Op typeClass, Id typeId, const std::vector<Id>& comps)
 {
-    Instruction* constant = 0;
+    Instruction* constant = nullptr;
     bool found = false;
     for (int i = 0; i < (int)groupedConstants[typeClass].size(); ++i) {
         constant = groupedConstants[typeClass][i];
@@ -1702,7 +1757,7 @@
 
 Id Builder::findStructConstant(Id typeId, const std::vector<Id>& comps)
 {
-    Instruction* constant = 0;
+    Instruction* constant = nullptr;
     bool found = false;
     for (int i = 0; i < (int)groupedStructConstants[typeId].size(); ++i) {
         constant = groupedStructConstants[typeId][i];
@@ -1735,6 +1790,7 @@
     case OpTypeVector:
     case OpTypeArray:
     case OpTypeMatrix:
+    case OpTypeCooperativeMatrixKHR:
     case OpTypeCooperativeMatrixNV:
         if (! specConstant) {
             Id existing = findCompositeConstant(typeClass, typeId, members);
@@ -1782,6 +1838,10 @@
 // Currently relying on the fact that all 'value' of interest are small non-negative values.
 void Builder::addExecutionMode(Function* entryPoint, ExecutionMode mode, int value1, int value2, int value3)
 {
+    // entryPoint can be null if we are in compile-only mode
+    if (!entryPoint)
+        return;
+
     Instruction* instr = new Instruction(OpExecutionMode);
     instr->addIdOperand(entryPoint->getId());
     instr->addImmediateOperand(mode);
@@ -1797,6 +1857,10 @@
 
 void Builder::addExecutionMode(Function* entryPoint, ExecutionMode mode, const std::vector<unsigned>& literals)
 {
+    // entryPoint can be null if we are in compile-only mode
+    if (!entryPoint)
+        return;
+
     Instruction* instr = new Instruction(OpExecutionMode);
     instr->addIdOperand(entryPoint->getId());
     instr->addImmediateOperand(mode);
@@ -1808,6 +1872,10 @@
 
 void Builder::addExecutionModeId(Function* entryPoint, ExecutionMode mode, const std::vector<Id>& operandIds)
 {
+    // entryPoint can be null if we are in compile-only mode
+    if (!entryPoint)
+        return;
+
     Instruction* instr = new Instruction(OpExecutionModeId);
     instr->addIdOperand(entryPoint->getId());
     instr->addImmediateOperand(mode);
@@ -1891,6 +1959,16 @@
     decorations.push_back(std::unique_ptr<Instruction>(dec));
 }
 
+void Builder::addLinkageDecoration(Id id, const char* name, spv::LinkageType linkType) {
+    Instruction* dec = new Instruction(OpDecorate);
+    dec->addIdOperand(id);
+    dec->addImmediateOperand(spv::DecorationLinkageAttributes);
+    dec->addStringOperand(name);
+    dec->addImmediateOperand(linkType);
+
+    decorations.push_back(std::unique_ptr<Instruction>(dec));
+}
+
 void Builder::addDecorationId(Id id, Decoration decoration, Id idDecoration)
 {
     if (decoration == spv::DecorationMax)
@@ -1995,7 +2073,7 @@
         emitNonSemanticShaderDebugInfo = false;
     }
 
-    entryPointFunction = makeFunctionEntry(NoPrecision, returnType, entryPoint, paramsTypes, paramNames, decorations, &entry);
+    entryPointFunction = makeFunctionEntry(NoPrecision, returnType, entryPoint, LinkageTypeMax, paramsTypes, paramNames, decorations, &entry);
 
     emitNonSemanticShaderDebugInfo = restoreNonSemanticShaderDebugInfo;
 
@@ -2003,7 +2081,7 @@
 }
 
 // Comments in header
-Function* Builder::makeFunctionEntry(Decoration precision, Id returnType, const char* name,
+Function* Builder::makeFunctionEntry(Decoration precision, Id returnType, const char* name, LinkageType linkType,
                                      const std::vector<Id>& paramTypes, const std::vector<char const*>& paramNames,
                                      const std::vector<std::vector<Decoration>>& decorations, Block **entry)
 {
@@ -2011,7 +2089,7 @@
     Id typeId = makeFunctionType(returnType, paramTypes);
     Id firstParamId = paramTypes.size() == 0 ? 0 : getUniqueIds((int)paramTypes.size());
     Id funcId = getUniqueId();
-    Function* function = new Function(funcId, returnType, typeId, firstParamId, module);
+    Function* function = new Function(funcId, returnType, typeId, firstParamId, linkType, name, module);
 
     // Set up the precisions
     setPrecision(function->getId(), precision);
@@ -2047,11 +2125,16 @@
         assert(paramTypes.size() == paramNames.size());
         for(size_t p = 0; p < paramTypes.size(); ++p)
         {
-            auto const& paramType = paramTypes[p];
-            assert(isPointerType(paramType) || isArrayType(paramType));
-            assert(debugId[getContainedTypeId(paramType)] != 0);
+            auto getParamTypeId = [this](Id const& typeId) {
+                if (isPointerType(typeId) || isArrayType(typeId)) {
+                    return getContainedTypeId(typeId);
+                }
+                else {
+                    return typeId;
+                }
+            };
             auto const& paramName = paramNames[p];
-            auto const debugLocalVariableId = createDebugLocalVariable(debugId[getContainedTypeId(paramType)], paramName, p+1);
+            auto const debugLocalVariableId = createDebugLocalVariable(debugId[getParamTypeId(paramTypes[p])], paramName, p+1);
             debugId[firstParamId + p] = debugLocalVariableId;
 
             makeDebugDeclare(debugLocalVariableId, firstParamId + p);
@@ -2070,7 +2153,8 @@
     return function;
 }
 
-Id Builder::makeDebugFunction(Function* function, Id nameId, Id funcTypeId) {
+Id Builder::makeDebugFunction([[maybe_unused]] Function* function, Id nameId, Id funcTypeId)
+{
     assert(function != nullptr);
     assert(nameId != 0);
     assert(funcTypeId != 0);
@@ -2095,6 +2179,8 @@
 }
 
 Id Builder::makeDebugLexicalBlock(uint32_t line) {
+    assert(!currentDebugScopeId.empty());
+
     Id lexId = getUniqueId();
     auto lex = new Instruction(lexId, makeVoidType(), OpExtInst);
     lex->addIdOperand(nonSemanticShaderDebugInfo);
@@ -2173,6 +2259,12 @@
         defInst->addIdOperand(funcId);
         buildPoint->addInstruction(std::unique_ptr<Instruction>(defInst));
     }
+
+    if (auto linkType = function->getLinkType(); linkType != LinkageTypeMax) {
+        Id funcId = function->getFuncId();
+        addCapability(CapabilityLinkage);
+        addLinkageDecoration(funcId, function->getExportName(), linkType);
+    }
 }
 
 // Comments in header
@@ -2363,7 +2455,24 @@
     return length->getResultId();
 }
 
-Id Builder::createCooperativeMatrixLength(Id type)
+Id Builder::createCooperativeMatrixLengthKHR(Id type)
+{
+    spv::Id intType = makeUintType(32);
+
+    // Generate code for spec constants if in spec constant operation
+    // generation mode.
+    if (generatingOpCodeForSpecConst) {
+        return createSpecConstantOp(OpCooperativeMatrixLengthKHR, intType, std::vector<Id>(1, type), std::vector<Id>());
+    }
+
+    Instruction* length = new Instruction(getUniqueId(), intType, OpCooperativeMatrixLengthKHR);
+    length->addIdOperand(type);
+    buildPoint->addInstruction(std::unique_ptr<Instruction>(length));
+
+    return length->getResultId();
+}
+
+Id Builder::createCooperativeMatrixLengthNV(Id type)
 {
     spv::Id intType = makeUintType(32);
 
@@ -2734,52 +2843,47 @@
 Id Builder::createTextureCall(Decoration precision, Id resultType, bool sparse, bool fetch, bool proj, bool gather,
     bool noImplicitLod, const TextureParameters& parameters, ImageOperandsMask signExtensionMask)
 {
-    static const int maxTextureArgs = 10;
-    Id texArgs[maxTextureArgs] = {};
+    std::vector<Id> texArgs;
 
     //
     // Set up the fixed arguments
     //
-    int numArgs = 0;
     bool explicitLod = false;
-    texArgs[numArgs++] = parameters.sampler;
-    texArgs[numArgs++] = parameters.coords;
+    texArgs.push_back(parameters.sampler);
+    texArgs.push_back(parameters.coords);
     if (parameters.Dref != NoResult)
-        texArgs[numArgs++] = parameters.Dref;
+        texArgs.push_back(parameters.Dref);
     if (parameters.component != NoResult)
-        texArgs[numArgs++] = parameters.component;
+        texArgs.push_back(parameters.component);
 
-#ifndef GLSLANG_WEB
     if (parameters.granularity != NoResult)
-        texArgs[numArgs++] = parameters.granularity;
+        texArgs.push_back(parameters.granularity);
     if (parameters.coarse != NoResult)
-        texArgs[numArgs++] = parameters.coarse;
-#endif
+        texArgs.push_back(parameters.coarse);
 
     //
     // Set up the optional arguments
     //
-    int optArgNum = numArgs;    // track which operand, if it exists, is the mask of optional arguments
-    ++numArgs;                  // speculatively make room for the mask operand
+    size_t optArgNum = texArgs.size(); // the position of the mask for the optional arguments, if any.
     ImageOperandsMask mask = ImageOperandsMaskNone; // the mask operand
     if (parameters.bias) {
         mask = (ImageOperandsMask)(mask | ImageOperandsBiasMask);
-        texArgs[numArgs++] = parameters.bias;
+        texArgs.push_back(parameters.bias);
     }
     if (parameters.lod) {
         mask = (ImageOperandsMask)(mask | ImageOperandsLodMask);
-        texArgs[numArgs++] = parameters.lod;
+        texArgs.push_back(parameters.lod);
         explicitLod = true;
     } else if (parameters.gradX) {
         mask = (ImageOperandsMask)(mask | ImageOperandsGradMask);
-        texArgs[numArgs++] = parameters.gradX;
-        texArgs[numArgs++] = parameters.gradY;
+        texArgs.push_back(parameters.gradX);
+        texArgs.push_back(parameters.gradY);
         explicitLod = true;
     } else if (noImplicitLod && ! fetch && ! gather) {
         // have to explicitly use lod of 0 if not allowed to have them be implicit, and
         // we would otherwise be about to issue an implicit instruction
         mask = (ImageOperandsMask)(mask | ImageOperandsLodMask);
-        texArgs[numArgs++] = makeFloatConstant(0.0);
+        texArgs.push_back(makeFloatConstant(0.0));
         explicitLod = true;
     }
     if (parameters.offset) {
@@ -2789,24 +2893,23 @@
             addCapability(CapabilityImageGatherExtended);
             mask = (ImageOperandsMask)(mask | ImageOperandsOffsetMask);
         }
-        texArgs[numArgs++] = parameters.offset;
+        texArgs.push_back(parameters.offset);
     }
     if (parameters.offsets) {
         addCapability(CapabilityImageGatherExtended);
         mask = (ImageOperandsMask)(mask | ImageOperandsConstOffsetsMask);
-        texArgs[numArgs++] = parameters.offsets;
+        texArgs.push_back(parameters.offsets);
     }
-#ifndef GLSLANG_WEB
     if (parameters.sample) {
         mask = (ImageOperandsMask)(mask | ImageOperandsSampleMask);
-        texArgs[numArgs++] = parameters.sample;
+        texArgs.push_back(parameters.sample);
     }
     if (parameters.lodClamp) {
         // capability if this bit is used
         addCapability(CapabilityMinLod);
 
         mask = (ImageOperandsMask)(mask | ImageOperandsMinLodMask);
-        texArgs[numArgs++] = parameters.lodClamp;
+        texArgs.push_back(parameters.lodClamp);
     }
     if (parameters.nonprivate) {
         mask = mask | ImageOperandsNonPrivateTexelKHRMask;
@@ -2814,12 +2917,10 @@
     if (parameters.volatil) {
         mask = mask | ImageOperandsVolatileTexelKHRMask;
     }
-#endif
     mask = mask | signExtensionMask;
-    if (mask == ImageOperandsMaskNone)
-        --numArgs;  // undo speculative reservation for the mask argument
-    else
-        texArgs[optArgNum] = mask;
+    // insert the operand for the mask, if any bits were set.
+    if (mask != ImageOperandsMaskNone)
+        texArgs.insert(texArgs.begin() + optArgNum, mask);
 
     //
     // Set up the instruction
@@ -2830,7 +2931,6 @@
             opCode = OpImageSparseFetch;
         else
             opCode = OpImageFetch;
-#ifndef GLSLANG_WEB
     } else if (parameters.granularity && parameters.coarse) {
         opCode = OpImageSampleFootprintNV;
     } else if (gather) {
@@ -2844,7 +2944,6 @@
                 opCode = OpImageSparseGather;
             else
                 opCode = OpImageGather;
-#endif
     } else if (explicitLod) {
         if (parameters.Dref) {
             if (proj)
@@ -2923,11 +3022,11 @@
 
     // Build the SPIR-V instruction
     Instruction* textureInst = new Instruction(getUniqueId(), resultType, opCode);
-    for (int op = 0; op < optArgNum; ++op)
+    for (size_t op = 0; op < optArgNum; ++op)
         textureInst->addIdOperand(texArgs[op]);
-    if (optArgNum < numArgs)
+    if (optArgNum < texArgs.size())
         textureInst->addImmediateOperand(texArgs[optArgNum]);
-    for (int op = optArgNum + 1; op < numArgs; ++op)
+    for (size_t op = optArgNum + 1; op < texArgs.size(); ++op)
         textureInst->addIdOperand(texArgs[op]);
     setPrecision(textureInst->getResultId(), precision);
     buildPoint->addInstruction(std::unique_ptr<Instruction>(textureInst));
@@ -3207,12 +3306,7 @@
     int numRows = getTypeNumRows(resultTypeId);
 
     Instruction* instr = module.getInstruction(componentTypeId);
-#ifdef GLSLANG_WEB
-    const unsigned bitCount = 32;
-    assert(bitCount == instr->getImmediateOperand(0));
-#else
     const unsigned bitCount = instr->getImmediateOperand(0);
-#endif
 
     // Optimize matrix constructed from a bigger matrix
     if (isMatrix(sources[0]) && getNumColumns(sources[0]) >= numCols && getNumRows(sources[0]) >= numRows) {
@@ -3332,7 +3426,7 @@
     builder(gb),
     condition(cond),
     control(ctrl),
-    elseBlock(0)
+    elseBlock(nullptr)
 {
     function = &builder.getBuildPoint()->getParent();
 
@@ -4033,4 +4127,4 @@
     }
 }
 
-}; // end spv namespace
+} // end spv namespace
diff --git a/SPIRV/SpvBuilder.h b/SPIRV/SpvBuilder.h
index f7fdc6a..2e1c07d 100644
--- a/SPIRV/SpvBuilder.h
+++ b/SPIRV/SpvBuilder.h
@@ -103,7 +103,7 @@
         stringIds[file_c_str] = strId;
         return strId;
     }
-    spv::Id getSourceFile() const 
+    spv::Id getSourceFile() const
     {
         return sourceFileStringId;
     }
@@ -203,7 +203,9 @@
     Id makeImageType(Id sampledType, Dim, bool depth, bool arrayed, bool ms, unsigned sampled, ImageFormat format);
     Id makeSamplerType();
     Id makeSampledImageType(Id imageType);
-    Id makeCooperativeMatrixType(Id component, Id scope, Id rows, Id cols);
+    Id makeCooperativeMatrixTypeKHR(Id component, Id scope, Id rows, Id cols, Id use);
+    Id makeCooperativeMatrixTypeNV(Id component, Id scope, Id rows, Id cols);
+    Id makeCooperativeMatrixTypeWithSameShape(Id component, Id otherType);
     Id makeGenericType(spv::Op opcode, std::vector<spv::IdImmediate>& operands);
 
     // SPIR-V NonSemantic Shader DebugInfo Instructions
@@ -240,6 +242,8 @@
     Id makeAccelerationStructureType();
     // rayQueryEXT type
     Id makeRayQueryType();
+    // hitObjectNV type
+    Id makeHitObjectNVType();
 
     // For querying about types.
     Id getTypeId(Id resultId) const { return module.getTypeId(resultId); }
@@ -257,6 +261,7 @@
     ImageFormat getImageTypeFormat(Id typeId) const
         { return (ImageFormat)module.getInstruction(typeId)->getImmediateOperand(6); }
     Id getResultingAccessChainType() const;
+    Id getIdOperand(Id resultId, int idx) { return module.getInstruction(resultId)->getIdOperand(idx); }
 
     bool isPointer(Id resultId)      const { return isPointerType(getTypeId(resultId)); }
     bool isScalar(Id resultId)       const { return isScalarType(getTypeId(resultId)); }
@@ -281,11 +286,10 @@
     bool isMatrixType(Id typeId)       const { return getTypeClass(typeId) == OpTypeMatrix; }
     bool isStructType(Id typeId)       const { return getTypeClass(typeId) == OpTypeStruct; }
     bool isArrayType(Id typeId)        const { return getTypeClass(typeId) == OpTypeArray; }
-#ifdef GLSLANG_WEB
-    bool isCooperativeMatrixType(Id typeId)const { return false; }
-#else
-    bool isCooperativeMatrixType(Id typeId)const { return getTypeClass(typeId) == OpTypeCooperativeMatrixNV; }
-#endif
+    bool isCooperativeMatrixType(Id typeId)const
+    {
+        return getTypeClass(typeId) == OpTypeCooperativeMatrixKHR || getTypeClass(typeId) == OpTypeCooperativeMatrixNV;
+    }
     bool isAggregateType(Id typeId)    const
         { return isArrayType(typeId) || isStructType(typeId) || isCooperativeMatrixType(typeId); }
     bool isImageType(Id typeId)        const { return getTypeClass(typeId) == OpTypeImage; }
@@ -389,6 +393,7 @@
     void addDecoration(Id, Decoration, const char*);
     void addDecoration(Id, Decoration, const std::vector<unsigned>& literals);
     void addDecoration(Id, Decoration, const std::vector<const char*>& strings);
+    void addLinkageDecoration(Id id, const char* name, spv::LinkageType linkType);
     void addDecorationId(Id id, Decoration, Id idDecoration);
     void addDecorationId(Id id, Decoration, const std::vector<Id>& operandIds);
     void addMemberDecoration(Id, unsigned int member, Decoration, int num = -1);
@@ -413,8 +418,9 @@
     // Return the function, pass back the entry.
     // The returned pointer is only valid for the lifetime of this builder.
     Function* makeFunctionEntry(Decoration precision, Id returnType, const char* name,
-        const std::vector<Id>& paramTypes, const std::vector<char const*>& paramNames,
-        const std::vector<std::vector<Decoration>>& precisions, Block **entry = 0);
+        LinkageType linkType, const std::vector<Id>& paramTypes,
+        const std::vector<char const*>& paramNames,
+        const std::vector<std::vector<Decoration>>& precisions, Block **entry = nullptr);
 
     // Create a return. An 'implicit' return is one not appearing in the source
     // code.  In the case of an implicit return, no post-return block is inserted.
@@ -462,8 +468,10 @@
     // Create an OpArrayLength instruction
     Id createArrayLength(Id base, unsigned int member);
 
+    // Create an OpCooperativeMatrixLengthKHR instruction
+    Id createCooperativeMatrixLengthKHR(Id type);
     // Create an OpCooperativeMatrixLengthNV instruction
-    Id createCooperativeMatrixLength(Id type);
+    Id createCooperativeMatrixLengthNV(Id type);
 
     // Create an OpCompositeExtract instruction
     Id createCompositeExtract(Id composite, Id typeId, unsigned index);
@@ -698,11 +706,6 @@
         // Accumulate whether anything in the chain of structures has coherent decorations.
         struct CoherentFlags {
             CoherentFlags() { clear(); }
-#ifdef GLSLANG_WEB
-            void clear() { }
-            bool isVolatile() const { return false; }
-            CoherentFlags operator |=(const CoherentFlags &other) { return *this; }
-#else
             bool isVolatile() const { return volatil; }
             bool isNonUniform() const { return nonUniform; }
             bool anyCoherent() const {
@@ -747,7 +750,6 @@
                 nonUniform |= other.nonUniform;
                 return *this;
             }
-#endif
         };
         CoherentFlags coherentFlags;
     };
@@ -828,19 +830,17 @@
 
     // Add capabilities, extensions, remove unneeded decorations, etc.,
     // based on the resulting SPIR-V.
-    void postProcess();
+    void postProcess(bool compileOnly);
 
     // Prune unreachable blocks in the CFG and remove unneeded decorations.
     void postProcessCFG();
 
-#ifndef GLSLANG_WEB
     // Add capabilities, extensions based on instructions in the module.
     void postProcessFeatures();
     // Hook to visit each instruction in a block in a function
     void postProcess(Instruction&);
     // Hook to visit each non-32-bit sized float/int operation in a block.
     void postProcessType(const Instruction&, spv::Id typeId);
-#endif
 
     void dump(std::vector<unsigned int>&) const;
 
diff --git a/SPIRV/SpvPostProcess.cpp b/SPIRV/SpvPostProcess.cpp
index dd6dabc..13001a6 100644
--- a/SPIRV/SpvPostProcess.cpp
+++ b/SPIRV/SpvPostProcess.cpp
@@ -52,11 +52,12 @@
     #include "GLSL.ext.EXT.h"
     #include "GLSL.ext.AMD.h"
     #include "GLSL.ext.NV.h"
+    #include "GLSL.ext.ARM.h"
+    #include "GLSL.ext.QCOM.h"
 }
 
 namespace spv {
 
-#ifndef GLSLANG_WEB
 // Hook to visit each operand type and result type of an instruction.
 // Will be called multiple times for one instruction, once for each typed
 // operand and the result.
@@ -333,7 +334,6 @@
         }
     }
 }
-#endif
 
 // comment in header
 void Builder::postProcessCFG()
@@ -394,7 +394,6 @@
         decorations.end());
 }
 
-#ifndef GLSLANG_WEB
 // comment in header
 void Builder::postProcessFeatures() {
     // Add per-instruction capabilities, extensions, etc.,
@@ -482,14 +481,15 @@
         }
     }
 }
-#endif
 
 // comment in header
-void Builder::postProcess() {
-  postProcessCFG();
-#ifndef GLSLANG_WEB
-  postProcessFeatures();
-#endif
+void Builder::postProcess(bool compileOnly)
+{
+    // postProcessCFG needs an entrypoint to determine what is reachable, but if we are not creating an "executable" shader, we don't have an entrypoint
+    if (!compileOnly)
+        postProcessCFG();
+
+    postProcessFeatures();
 }
 
 }; // end spv namespace
diff --git a/SPIRV/SpvTools.cpp b/SPIRV/SpvTools.cpp
index 2529993..ff04f4f 100644
--- a/SPIRV/SpvTools.cpp
+++ b/SPIRV/SpvTools.cpp
@@ -212,8 +212,7 @@
     optimizer.RegisterPass(spvtools::CreateInterpolateFixupPass());
     if (options->optimizeSize) {
         optimizer.RegisterPass(spvtools::CreateRedundancyEliminationPass());
-        if (intermediate.getStage() == EShLanguage::EShLangVertex)
-            optimizer.RegisterPass(spvtools::CreateEliminateDeadInputComponentsPass());
+        optimizer.RegisterPass(spvtools::CreateEliminateDeadInputComponentsSafePass());
     }
     optimizer.RegisterPass(spvtools::CreateAggressiveDCEPass());
     optimizer.RegisterPass(spvtools::CreateCFGCleanupPass());
@@ -224,6 +223,56 @@
     optimizer.Run(spirv.data(), spirv.size(), &spirv, spvOptOptions);
 }
 
+bool SpirvToolsAnalyzeDeadOutputStores(spv_target_env target_env, std::vector<unsigned int>& spirv,
+                                       std::unordered_set<uint32_t>* live_locs,
+                                       std::unordered_set<uint32_t>* live_builtins,
+                                       spv::SpvBuildLogger*)
+{
+  spvtools::Optimizer optimizer(target_env);
+  optimizer.SetMessageConsumer(OptimizerMesssageConsumer);
+
+  optimizer.RegisterPass(spvtools::CreateAnalyzeLiveInputPass(live_locs, live_builtins));
+
+  spvtools::OptimizerOptions spvOptOptions;
+  optimizer.SetTargetEnv(target_env);
+  spvOptOptions.set_run_validator(false);
+  return optimizer.Run(spirv.data(), spirv.size(), &spirv, spvOptOptions);
+}
+
+void SpirvToolsEliminateDeadOutputStores(spv_target_env target_env, std::vector<unsigned int>& spirv,
+                                         std::unordered_set<uint32_t>* live_locs,
+                                         std::unordered_set<uint32_t>* live_builtins,
+                                         spv::SpvBuildLogger*)
+{
+  spvtools::Optimizer optimizer(target_env);
+  optimizer.SetMessageConsumer(OptimizerMesssageConsumer);
+
+  optimizer.RegisterPass(spvtools::CreateEliminateDeadOutputStoresPass(live_locs, live_builtins));
+  optimizer.RegisterPass(spvtools::CreateAggressiveDCEPass(false, true));
+  optimizer.RegisterPass(spvtools::CreateEliminateDeadOutputComponentsPass());
+  optimizer.RegisterPass(spvtools::CreateAggressiveDCEPass(false, true));
+
+  spvtools::OptimizerOptions spvOptOptions;
+  optimizer.SetTargetEnv(target_env);
+  spvOptOptions.set_run_validator(false);
+  optimizer.Run(spirv.data(), spirv.size(), &spirv, spvOptOptions);
+}
+
+void SpirvToolsEliminateDeadInputComponents(spv_target_env target_env, std::vector<unsigned int>& spirv,
+                                            spv::SpvBuildLogger*)
+{
+  spvtools::Optimizer optimizer(target_env);
+  optimizer.SetMessageConsumer(OptimizerMesssageConsumer);
+
+  optimizer.RegisterPass(spvtools::CreateEliminateDeadInputComponentsPass());
+  optimizer.RegisterPass(spvtools::CreateAggressiveDCEPass());
+
+  spvtools::OptimizerOptions spvOptOptions;
+  optimizer.SetTargetEnv(target_env);
+  spvOptOptions.set_run_validator(false);
+  optimizer.Run(spirv.data(), spirv.size(), &spirv, spvOptOptions);
+}
+
 // Apply the SPIRV-Tools optimizer to strip debug info from SPIR-V.  This is implicitly done by
 // SpirvToolsTransform if spvOptions->stripDebugInfo is set, but can be called separately if
 // optimization is disabled.
diff --git a/SPIRV/SpvTools.h b/SPIRV/SpvTools.h
index 5386048..a4ce11b 100644
--- a/SPIRV/SpvTools.h
+++ b/SPIRV/SpvTools.h
@@ -61,10 +61,14 @@
     bool validate {false};
     bool emitNonSemanticShaderDebugInfo {false};
     bool emitNonSemanticShaderDebugSource{ false };
+    bool compileOnly{false};
 };
 
 #if ENABLE_OPT
 
+// Translate glslang's view of target versioning to what SPIRV-Tools uses.
+spv_target_env MapToSpirvToolsEnv(const SpvVersion& spvVersion, spv::SpvBuildLogger* logger);
+
 // Use the SPIRV-Tools disassembler to print SPIR-V using a SPV_ENV_UNIVERSAL_1_3 environment.
 void SpirvToolsDisassemble(std::ostream& out, const std::vector<unsigned int>& spirv);
 
@@ -80,6 +84,22 @@
 void SpirvToolsTransform(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv,
                          spv::SpvBuildLogger*, const SpvOptions*);
 
+// Apply the SPIRV-Tools EliminateDeadInputComponents pass to generated SPIR-V. Put result in |spirv|.
+void SpirvToolsEliminateDeadInputComponents(spv_target_env target_env, std::vector<unsigned int>& spirv,
+                                            spv::SpvBuildLogger*);
+
+// Apply the SPIRV-Tools AnalyzeDeadOutputStores pass to generated SPIR-V. Put result in |live_locs|.
+// Return true if the result is valid.
+bool SpirvToolsAnalyzeDeadOutputStores(spv_target_env target_env, std::vector<unsigned int>& spirv,
+                                       std::unordered_set<uint32_t>* live_locs,
+                                       std::unordered_set<uint32_t>* live_builtins, spv::SpvBuildLogger*);
+
+// Apply the SPIRV-Tools EliminateDeadOutputStores and AggressiveDeadCodeElimination passes to generated SPIR-V using
+// |live_locs|. Put result in |spirv|.
+void SpirvToolsEliminateDeadOutputStores(spv_target_env target_env, std::vector<unsigned int>& spirv,
+                                         std::unordered_set<uint32_t>* live_locs,
+                                         std::unordered_set<uint32_t>* live_builtins, spv::SpvBuildLogger*);
+
 // Apply the SPIRV-Tools optimizer to strip debug info from SPIR-V.  This is implicitly done by
 // SpirvToolsTransform if spvOptions->stripDebugInfo is set, but can be called separately if
 // optimization is disabled.
diff --git a/SPIRV/disassemble.cpp b/SPIRV/disassemble.cpp
index 74dd605..c5e961c 100644
--- a/SPIRV/disassemble.cpp
+++ b/SPIRV/disassemble.cpp
@@ -54,6 +54,9 @@
         #include "GLSL.std.450.h"
         #include "GLSL.ext.AMD.h"
         #include "GLSL.ext.NV.h"
+        #include "GLSL.ext.ARM.h"
+        #include "NonSemanticShaderDebugInfo100.h"
+        #include "GLSL.ext.QCOM.h"
     }
 }
 const char* GlslStd450DebugNames[spv::GLSLstd450Count];
@@ -62,6 +65,7 @@
 
 static const char* GLSLextAMDGetDebugNames(const char*, unsigned);
 static const char* GLSLextNVGetDebugNames(const char*, unsigned);
+static const char* NonSemanticShaderDebugInfo100GetDebugNames(unsigned);
 
 static void Kill(std::ostream& out, const char* message)
 {
@@ -76,6 +80,7 @@
     GLSLextNVInst,
     OpenCLExtInst,
     NonSemanticDebugPrintfExtInst,
+    NonSemanticShaderDebugInfo100
 };
 
 // Container class for a single instance of a SPIR-V stream, with methods for disassembly.
@@ -501,6 +506,8 @@
                     extInstSet = OpenCLExtInst;
                 } else if (strcmp("NonSemantic.DebugPrintf", name) == 0) {
                     extInstSet = NonSemanticDebugPrintfExtInst;
+                } else if (strcmp("NonSemantic.Shader.DebugInfo.100", name) == 0) {
+                    extInstSet = NonSemanticShaderDebugInfo100;
                 } else if (strcmp(spv::E_SPV_AMD_shader_ballot, name) == 0 ||
                            strcmp(spv::E_SPV_AMD_shader_trinary_minmax, name) == 0 ||
                            strcmp(spv::E_SPV_AMD_shader_explicit_vertex_parameter, name) == 0 ||
@@ -509,7 +516,7 @@
                 } else if (strcmp(spv::E_SPV_NV_sample_mask_override_coverage, name) == 0 ||
                           strcmp(spv::E_SPV_NV_geometry_shader_passthrough, name) == 0 ||
                           strcmp(spv::E_SPV_NV_viewport_array2, name) == 0 ||
-                          strcmp(spv::E_SPV_NVX_multiview_per_view_attributes, name) == 0 || 
+                          strcmp(spv::E_SPV_NVX_multiview_per_view_attributes, name) == 0 ||
                           strcmp(spv::E_SPV_NV_fragment_shader_barycentric, name) == 0 ||
                           strcmp(spv::E_SPV_NV_mesh_shader, name) == 0) {
                     extInstSet = GLSLextNVInst;
@@ -526,6 +533,8 @@
                     out << "(" << GLSLextNVGetDebugNames(name, entrypoint) << ")";
                 } else if (extInstSet == NonSemanticDebugPrintfExtInst) {
                     out << "(DebugPrintf)";
+                } else if (extInstSet == NonSemanticShaderDebugInfo100) {
+                    out << "(" << NonSemanticShaderDebugInfo100GetDebugNames(entrypoint) << ")";
                 }
             }
             break;
@@ -749,6 +758,59 @@
     return "Bad";
 }
 
+static const char* NonSemanticShaderDebugInfo100GetDebugNames(unsigned entrypoint)
+{
+    switch (entrypoint) {
+        case NonSemanticShaderDebugInfo100DebugInfoNone:                        return "DebugInfoNone";
+        case NonSemanticShaderDebugInfo100DebugCompilationUnit:                 return "DebugCompilationUnit";
+        case NonSemanticShaderDebugInfo100DebugTypeBasic:                       return "DebugTypeBasic";
+        case NonSemanticShaderDebugInfo100DebugTypePointer:                     return "DebugTypePointer";
+        case NonSemanticShaderDebugInfo100DebugTypeQualifier:                   return "DebugTypeQualifier";
+        case NonSemanticShaderDebugInfo100DebugTypeArray:                       return "DebugTypeArray";
+        case NonSemanticShaderDebugInfo100DebugTypeVector:                      return "DebugTypeVector";
+        case NonSemanticShaderDebugInfo100DebugTypedef:                         return "DebugTypedef";
+        case NonSemanticShaderDebugInfo100DebugTypeFunction:                    return "DebugTypeFunction";
+        case NonSemanticShaderDebugInfo100DebugTypeEnum:                        return "DebugTypeEnum";
+        case NonSemanticShaderDebugInfo100DebugTypeComposite:                   return "DebugTypeComposite";
+        case NonSemanticShaderDebugInfo100DebugTypeMember:                      return "DebugTypeMember";
+        case NonSemanticShaderDebugInfo100DebugTypeInheritance:                 return "DebugTypeInheritance";
+        case NonSemanticShaderDebugInfo100DebugTypePtrToMember:                 return "DebugTypePtrToMember";
+        case NonSemanticShaderDebugInfo100DebugTypeTemplate:                    return "DebugTypeTemplate";
+        case NonSemanticShaderDebugInfo100DebugTypeTemplateParameter:           return "DebugTypeTemplateParameter";
+        case NonSemanticShaderDebugInfo100DebugTypeTemplateTemplateParameter:   return "DebugTypeTemplateTemplateParameter";
+        case NonSemanticShaderDebugInfo100DebugTypeTemplateParameterPack:       return "DebugTypeTemplateParameterPack";
+        case NonSemanticShaderDebugInfo100DebugGlobalVariable:                  return "DebugGlobalVariable";
+        case NonSemanticShaderDebugInfo100DebugFunctionDeclaration:             return "DebugFunctionDeclaration";
+        case NonSemanticShaderDebugInfo100DebugFunction:                        return "DebugFunction";
+        case NonSemanticShaderDebugInfo100DebugLexicalBlock:                    return "DebugLexicalBlock";
+        case NonSemanticShaderDebugInfo100DebugLexicalBlockDiscriminator:       return "DebugLexicalBlockDiscriminator";
+        case NonSemanticShaderDebugInfo100DebugScope:                           return "DebugScope";
+        case NonSemanticShaderDebugInfo100DebugNoScope:                         return "DebugNoScope";
+        case NonSemanticShaderDebugInfo100DebugInlinedAt:                       return "DebugInlinedAt";
+        case NonSemanticShaderDebugInfo100DebugLocalVariable:                   return "DebugLocalVariable";
+        case NonSemanticShaderDebugInfo100DebugInlinedVariable:                 return "DebugInlinedVariable";
+        case NonSemanticShaderDebugInfo100DebugDeclare:                         return "DebugDeclare";
+        case NonSemanticShaderDebugInfo100DebugValue:                           return "DebugValue";
+        case NonSemanticShaderDebugInfo100DebugOperation:                       return "DebugOperation";
+        case NonSemanticShaderDebugInfo100DebugExpression:                      return "DebugExpression";
+        case NonSemanticShaderDebugInfo100DebugMacroDef:                        return "DebugMacroDef";
+        case NonSemanticShaderDebugInfo100DebugMacroUndef:                      return "DebugMacroUndef";
+        case NonSemanticShaderDebugInfo100DebugImportedEntity:                  return "DebugImportedEntity";
+        case NonSemanticShaderDebugInfo100DebugSource:                          return "DebugSource";
+        case NonSemanticShaderDebugInfo100DebugFunctionDefinition:              return "DebugFunctionDefinition";
+        case NonSemanticShaderDebugInfo100DebugSourceContinued:                 return "DebugSourceContinued";
+        case NonSemanticShaderDebugInfo100DebugLine:                            return "DebugLine";
+        case NonSemanticShaderDebugInfo100DebugNoLine:                          return "DebugNoLine";
+        case NonSemanticShaderDebugInfo100DebugBuildIdentifier:                 return "DebugBuildIdentifier";
+        case NonSemanticShaderDebugInfo100DebugStoragePath:                     return "DebugStoragePath";
+        case NonSemanticShaderDebugInfo100DebugEntryPoint:                      return "DebugEntryPoint";
+        case NonSemanticShaderDebugInfo100DebugTypeMatrix:                      return "DebugTypeMatrix";
+        default:                                                                return "Bad";
+    }
+
+    return "Bad";
+}
+
 void Disassemble(std::ostream& out, const std::vector<unsigned int>& stream)
 {
     SpirvStream SpirvStream(out, stream);
diff --git a/SPIRV/doc.cpp b/SPIRV/doc.cpp
old mode 100644
new mode 100755
index b7fe3e7..53ce9e1
--- a/SPIRV/doc.cpp
+++ b/SPIRV/doc.cpp
@@ -45,6 +45,7 @@
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
+#include <mutex>
 
 namespace spv {
     extern "C" {
@@ -53,6 +54,8 @@
         #include "GLSL.ext.EXT.h"
         #include "GLSL.ext.AMD.h"
         #include "GLSL.ext.NV.h"
+        #include "GLSL.ext.ARM.h"
+        #include "GLSL.ext.QCOM.h"
     }
 }
 
@@ -214,6 +217,10 @@
     case ExecutionModeNoGlobalOffsetINTEL:      return "NoGlobalOffsetINTEL";
     case ExecutionModeNumSIMDWorkitemsINTEL:    return "NumSIMDWorkitemsINTEL";
 
+    case ExecutionModeNonCoherentColorAttachmentReadEXT:        return "NonCoherentColorAttachmentReadEXT";
+    case ExecutionModeNonCoherentDepthAttachmentReadEXT:        return "NonCoherentDepthAttachmentReadEXT";
+    case ExecutionModeNonCoherentStencilAttachmentReadEXT:      return "NonCoherentStencilAttachmentReadEXT";
+
     case ExecutionModeCeiling:
     default: return "Bad";
     }
@@ -245,6 +252,8 @@
 
     case StorageClassPhysicalStorageBufferEXT: return "PhysicalStorageBufferEXT";
     case StorageClassTaskPayloadWorkgroupEXT:  return "TaskPayloadWorkgroupEXT";
+    case StorageClassHitObjectAttributeNV:     return "HitObjectAttributeNV";
+    case StorageClassTileImageEXT:             return "TileImageEXT";
     default: return "Bad";
     }
 }
@@ -303,7 +312,9 @@
     case DecorationCeiling:
     default:  return "Bad";
 
-    case DecorationExplicitInterpAMD: return "ExplicitInterpAMD";
+    case DecorationWeightTextureQCOM:           return "DecorationWeightTextureQCOM";
+    case DecorationBlockMatchTextureQCOM:       return "DecorationBlockMatchTextureQCOM";
+    case DecorationExplicitInterpAMD:           return "ExplicitInterpAMD";
     case DecorationOverrideCoverageNV:          return "OverrideCoverageNV";
     case DecorationPassthroughNV:               return "PassthroughNV";
     case DecorationViewportRelativeNV:          return "ViewportRelativeNV";
@@ -311,7 +322,7 @@
     case DecorationPerPrimitiveNV:              return "PerPrimitiveNV";
     case DecorationPerViewNV:                   return "PerViewNV";
     case DecorationPerTaskNV:                   return "PerTaskNV";
-    
+
     case DecorationPerVertexKHR:                return "PerVertexKHR";
 
     case DecorationNonUniformEXT:           return "DecorationNonUniformEXT";
@@ -319,6 +330,8 @@
     case DecorationHlslSemanticGOOGLE:      return "DecorationHlslSemanticGOOGLE";
     case DecorationRestrictPointerEXT:      return "DecorationRestrictPointerEXT";
     case DecorationAliasedPointerEXT:       return "DecorationAliasedPointerEXT";
+
+    case DecorationHitObjectShaderRecordBufferNV:  return "DecorationHitObjectShaderRecordBufferNV";
     }
 }
 
@@ -400,6 +413,11 @@
     case BuiltInRayTminKHR:                  return "RayTminKHR";
     case BuiltInRayTmaxKHR:                  return "RayTmaxKHR";
     case BuiltInCullMaskKHR:                 return "CullMaskKHR";
+    case BuiltInHitTriangleVertexPositionsKHR: return "HitTriangleVertexPositionsKHR";
+    case BuiltInHitMicroTriangleVertexPositionsNV: return "HitMicroTriangleVertexPositionsNV";
+    case BuiltInHitMicroTriangleVertexBarycentricsNV: return "HitMicroTriangleVertexBarycentricsNV";
+    case BuiltInHitKindFrontFacingMicroTriangleNV: return "HitKindFrontFacingMicroTriangleNV";
+    case BuiltInHitKindBackFacingMicroTriangleNV: return "HitKindBackFacingMicroTriangleNV";
     case BuiltInInstanceCustomIndexKHR:      return "InstanceCustomIndexKHR";
     case BuiltInRayGeometryIndexKHR:         return "RayGeometryIndexKHR";
     case BuiltInObjectToWorldKHR:            return "ObjectToWorldKHR";
@@ -439,6 +457,11 @@
     case BuiltInPrimitiveLineIndicesEXT:         return "PrimitiveLineIndicesEXT";
     case BuiltInPrimitiveTriangleIndicesEXT:     return "PrimitiveTriangleIndicesEXT";
     case BuiltInCullPrimitiveEXT:                return "CullPrimitiveEXT";
+    case BuiltInCoreCountARM:           return "CoreCountARM";
+    case BuiltInCoreIDARM:              return "CoreIDARM";
+    case BuiltInCoreMaxIDARM:           return "CoreMaxIDARM";
+    case BuiltInWarpIDARM:              return "WarpIDARM";
+    case BuiltInWarpMaxIDARM:           return "BuiltInWarpMaxIDARM";
 
     default: return "Bad";
     }
@@ -454,6 +477,7 @@
     case 4:  return "Rect";
     case 5:  return "Buffer";
     case 6:  return "SubpassData";
+    case DimTileImageDataEXT:  return "TileImageDataEXT";
 
     default: return "Bad";
     }
@@ -568,7 +592,7 @@
     case 17: return "sRGBA";
     case 18: return "sBGRA";
 
-    default: 
+    default:
         return "Bad";
     }
 }
@@ -773,6 +797,21 @@
     }
 }
 
+const int CooperativeMatrixOperandsCeiling = 6;
+
+const char* CooperativeMatrixOperandsString(int op)
+{
+    switch (op) {
+    case CooperativeMatrixOperandsMatrixASignedComponentsShift:  return "ASignedComponents";
+    case CooperativeMatrixOperandsMatrixBSignedComponentsShift:  return "BSignedComponents";
+    case CooperativeMatrixOperandsMatrixCSignedComponentsShift:  return "CSignedComponents";
+    case CooperativeMatrixOperandsMatrixResultSignedComponentsShift:  return "ResultSignedComponents";
+    case CooperativeMatrixOperandsSaturatingAccumulationShift:   return "SaturatingAccumulation";
+
+    default: return "Bad";
+    }
+}
+
 const char* ScopeString(int mem)
 {
     switch (mem) {
@@ -854,7 +893,7 @@
     case 22: return "Int16";
     case 23: return "TessellationPointSize";
     case 24: return "GeometryPointSize";
-    case 25: return "ImageGatherExtended"; 
+    case 25: return "ImageGatherExtended";
     case 26: return "Bad";
     case 27: return "StorageImageMultisample";
     case 28: return "UniformBufferArrayDynamicIndexing";
@@ -941,6 +980,10 @@
     case CapabilityRayQueryKHR:                     return "RayQueryKHR";
     case CapabilityRayTracingProvisionalKHR:        return "RayTracingProvisionalKHR";
     case CapabilityRayTraversalPrimitiveCullingKHR: return "RayTraversalPrimitiveCullingKHR";
+    case CapabilityRayTracingPositionFetchKHR:      return "RayTracingPositionFetchKHR";
+    case CapabilityDisplacementMicromapNV:           return "DisplacementMicromapNV";
+    case CapabilityRayTracingDisplacementMicromapNV: return "CapabilityRayTracingDisplacementMicromapNV";
+    case CapabilityRayQueryPositionFetchKHR:        return "RayQueryPositionFetchKHR";
     case CapabilityComputeDerivativeGroupQuadsNV:   return "ComputeDerivativeGroupQuadsNV";
     case CapabilityComputeDerivativeGroupLinearNV:  return "ComputeDerivativeGroupLinearNV";
     case CapabilityFragmentBarycentricKHR:          return "FragmentBarycentricKHR";
@@ -974,12 +1017,17 @@
     case CapabilityVariablePointers:                    return "VariablePointers";
 
     case CapabilityCooperativeMatrixNV:     return "CooperativeMatrixNV";
+    case CapabilityCooperativeMatrixKHR:    return "CooperativeMatrixKHR";
     case CapabilityShaderSMBuiltinsNV:      return "ShaderSMBuiltinsNV";
 
     case CapabilityFragmentShaderSampleInterlockEXT:        return "CapabilityFragmentShaderSampleInterlockEXT";
     case CapabilityFragmentShaderPixelInterlockEXT:         return "CapabilityFragmentShaderPixelInterlockEXT";
     case CapabilityFragmentShaderShadingRateInterlockEXT:   return "CapabilityFragmentShaderShadingRateInterlockEXT";
 
+    case CapabilityTileImageColorReadAccessEXT:           return "TileImageColorReadAccessEXT";
+    case CapabilityTileImageDepthReadAccessEXT:           return "TileImageDepthReadAccessEXT";
+    case CapabilityTileImageStencilReadAccessEXT:         return "TileImageStencilReadAccessEXT";
+
     case CapabilityFragmentShadingRateKHR:                  return "FragmentShadingRateKHR";
 
     case CapabilityDemoteToHelperInvocationEXT:             return "DemoteToHelperInvocationEXT";
@@ -998,6 +1046,13 @@
     case CapabilityWorkgroupMemoryExplicitLayoutKHR:            return "CapabilityWorkgroupMemoryExplicitLayoutKHR";
     case CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR:  return "CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR";
     case CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR: return "CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR";
+    case CapabilityCoreBuiltinsARM:                             return "CoreBuiltinsARM";
+
+    case CapabilityShaderInvocationReorderNV:                return "ShaderInvocationReorderNV";
+
+    case CapabilityTextureSampleWeightedQCOM:           return "TextureSampleWeightedQCOM";
+    case CapabilityTextureBoxFilterQCOM:                return "TextureBoxFilterQCOM";
+    case CapabilityTextureBlockMatchQCOM:               return "TextureBlockMatchQCOM";
 
     default: return "Bad";
     }
@@ -1441,18 +1496,70 @@
     case OpRayQueryGetWorldRayOriginKHR:                                      return "OpRayQueryGetWorldRayOriginKHR";
     case OpRayQueryGetIntersectionObjectToWorldKHR:                           return "OpRayQueryGetIntersectionObjectToWorldKHR";
     case OpRayQueryGetIntersectionWorldToObjectKHR:                           return "OpRayQueryGetIntersectionWorldToObjectKHR";
+    case OpRayQueryGetIntersectionTriangleVertexPositionsKHR:                 return "OpRayQueryGetIntersectionTriangleVertexPositionsKHR";
 
     case OpTypeCooperativeMatrixNV:         return "OpTypeCooperativeMatrixNV";
     case OpCooperativeMatrixLoadNV:         return "OpCooperativeMatrixLoadNV";
     case OpCooperativeMatrixStoreNV:        return "OpCooperativeMatrixStoreNV";
     case OpCooperativeMatrixMulAddNV:       return "OpCooperativeMatrixMulAddNV";
     case OpCooperativeMatrixLengthNV:       return "OpCooperativeMatrixLengthNV";
+    case OpTypeCooperativeMatrixKHR:        return "OpTypeCooperativeMatrixKHR";
+    case OpCooperativeMatrixLoadKHR:        return "OpCooperativeMatrixLoadKHR";
+    case OpCooperativeMatrixStoreKHR:       return "OpCooperativeMatrixStoreKHR";
+    case OpCooperativeMatrixMulAddKHR:      return "OpCooperativeMatrixMulAddKHR";
+    case OpCooperativeMatrixLengthKHR:      return "OpCooperativeMatrixLengthKHR";
     case OpDemoteToHelperInvocationEXT:     return "OpDemoteToHelperInvocationEXT";
     case OpIsHelperInvocationEXT:           return "OpIsHelperInvocationEXT";
 
     case OpBeginInvocationInterlockEXT:     return "OpBeginInvocationInterlockEXT";
     case OpEndInvocationInterlockEXT:       return "OpEndInvocationInterlockEXT";
 
+    case OpTypeHitObjectNV:                     return "OpTypeHitObjectNV";
+    case OpHitObjectTraceRayNV:                 return "OpHitObjectTraceRayNV";
+    case OpHitObjectTraceRayMotionNV:           return "OpHitObjectTraceRayMotionNV";
+    case OpHitObjectRecordHitNV:                return "OpHitObjectRecordHitNV";
+    case OpHitObjectRecordHitMotionNV:          return "OpHitObjectRecordHitMotionNV";
+    case OpHitObjectRecordHitWithIndexNV:       return "OpHitObjectRecordHitWithIndexNV";
+    case OpHitObjectRecordHitWithIndexMotionNV: return "OpHitObjectRecordHitWithIndexMotionNV";
+    case OpHitObjectRecordMissNV:               return "OpHitObjectRecordMissNV";
+    case OpHitObjectRecordMissMotionNV:         return "OpHitObjectRecordMissMotionNV";
+    case OpHitObjectRecordEmptyNV:              return "OpHitObjectRecordEmptyNV";
+    case OpHitObjectExecuteShaderNV:            return "OpHitObjectExecuteShaderNV";
+    case OpReorderThreadWithHintNV:             return "OpReorderThreadWithHintNV";
+    case OpReorderThreadWithHitObjectNV:        return "OpReorderThreadWithHitObjectNV";
+    case OpHitObjectGetCurrentTimeNV:           return "OpHitObjectGetCurrentTimeNV";
+    case OpHitObjectGetAttributesNV:            return "OpHitObjectGetAttributesNV";
+    case OpHitObjectGetHitKindNV:               return "OpHitObjectGetFrontFaceNV";
+    case OpHitObjectGetPrimitiveIndexNV:        return "OpHitObjectGetPrimitiveIndexNV";
+    case OpHitObjectGetGeometryIndexNV:         return "OpHitObjectGetGeometryIndexNV";
+    case OpHitObjectGetInstanceIdNV:            return "OpHitObjectGetInstanceIdNV";
+    case OpHitObjectGetInstanceCustomIndexNV:   return "OpHitObjectGetInstanceCustomIndexNV";
+    case OpHitObjectGetObjectRayDirectionNV:    return "OpHitObjectGetObjectRayDirectionNV";
+    case OpHitObjectGetObjectRayOriginNV:       return "OpHitObjectGetObjectRayOriginNV";
+    case OpHitObjectGetWorldRayDirectionNV:     return "OpHitObjectGetWorldRayDirectionNV";
+    case OpHitObjectGetWorldRayOriginNV:        return "OpHitObjectGetWorldRayOriginNV";
+    case OpHitObjectGetWorldToObjectNV:         return "OpHitObjectGetWorldToObjectNV";
+    case OpHitObjectGetObjectToWorldNV:         return "OpHitObjectGetObjectToWorldNV";
+    case OpHitObjectGetRayTMaxNV:               return "OpHitObjectGetRayTMaxNV";
+    case OpHitObjectGetRayTMinNV:               return "OpHitObjectGetRayTMinNV";
+    case OpHitObjectIsEmptyNV:                  return "OpHitObjectIsEmptyNV";
+    case OpHitObjectIsHitNV:                    return "OpHitObjectIsHitNV";
+    case OpHitObjectIsMissNV:                   return "OpHitObjectIsMissNV";
+    case OpHitObjectGetShaderBindingTableRecordIndexNV: return "OpHitObjectGetShaderBindingTableRecordIndexNV";
+    case OpHitObjectGetShaderRecordBufferHandleNV:   return "OpHitObjectGetShaderRecordBufferHandleNV";
+
+    case OpFetchMicroTriangleVertexBarycentricNV:       return "OpFetchMicroTriangleVertexBarycentricNV";
+    case OpFetchMicroTriangleVertexPositionNV:    return "OpFetchMicroTriangleVertexPositionNV";
+
+    case OpColorAttachmentReadEXT:          return "OpColorAttachmentReadEXT";
+    case OpDepthAttachmentReadEXT:          return "OpDepthAttachmentReadEXT";
+    case OpStencilAttachmentReadEXT:        return "OpStencilAttachmentReadEXT";
+
+    case OpImageSampleWeightedQCOM:         return "OpImageSampleWeightedQCOM";
+    case OpImageBoxFilterQCOM:              return "OpImageBoxFilterQCOM";
+    case OpImageBlockMatchSADQCOM:          return "OpImageBlockMatchSADQCOM";
+    case OpImageBlockMatchSSDQCOM:          return "OpImageBlockMatchSSDQCOM";
+
     default:
         return "Bad";
     }
@@ -1472,1564 +1579,1831 @@
 EnumParameters SelectionControlParams[SelectControlCeiling];
 EnumParameters FunctionControlParams[FunctionControlCeiling];
 EnumParameters MemoryAccessParams[MemoryAccessCeiling];
+EnumParameters CooperativeMatrixOperandsParams[CooperativeMatrixOperandsCeiling];
 
 // Set up all the parameterizing descriptions of the opcodes, operands, etc.
 void Parameterize()
 {
     // only do this once.
-    static bool initialized = false;
-    if (initialized)
-        return;
-    initialized = true;
+    static std::once_flag initialized;
+    std::call_once(initialized, [](){
 
-    // Exceptions to having a result <id> and a resulting type <id>.
-    // (Everything is initialized to have both).
+        // Exceptions to having a result <id> and a resulting type <id>.
+        // (Everything is initialized to have both).
 
-    InstructionDesc[OpNop].setResultAndType(false, false);
-    InstructionDesc[OpSource].setResultAndType(false, false);
-    InstructionDesc[OpSourceContinued].setResultAndType(false, false);
-    InstructionDesc[OpSourceExtension].setResultAndType(false, false);
-    InstructionDesc[OpExtension].setResultAndType(false, false);
-    InstructionDesc[OpExtInstImport].setResultAndType(true, false);
-    InstructionDesc[OpCapability].setResultAndType(false, false);
-    InstructionDesc[OpMemoryModel].setResultAndType(false, false);
-    InstructionDesc[OpEntryPoint].setResultAndType(false, false);
-    InstructionDesc[OpExecutionMode].setResultAndType(false, false);
-    InstructionDesc[OpExecutionModeId].setResultAndType(false, false);
-    InstructionDesc[OpTypeVoid].setResultAndType(true, false);
-    InstructionDesc[OpTypeBool].setResultAndType(true, false);
-    InstructionDesc[OpTypeInt].setResultAndType(true, false);
-    InstructionDesc[OpTypeFloat].setResultAndType(true, false);
-    InstructionDesc[OpTypeVector].setResultAndType(true, false);
-    InstructionDesc[OpTypeMatrix].setResultAndType(true, false);
-    InstructionDesc[OpTypeImage].setResultAndType(true, false);
-    InstructionDesc[OpTypeSampler].setResultAndType(true, false);
-    InstructionDesc[OpTypeSampledImage].setResultAndType(true, false);
-    InstructionDesc[OpTypeArray].setResultAndType(true, false);
-    InstructionDesc[OpTypeRuntimeArray].setResultAndType(true, false);
-    InstructionDesc[OpTypeStruct].setResultAndType(true, false);
-    InstructionDesc[OpTypeOpaque].setResultAndType(true, false);
-    InstructionDesc[OpTypePointer].setResultAndType(true, false);
-    InstructionDesc[OpTypeForwardPointer].setResultAndType(false, false);
-    InstructionDesc[OpTypeFunction].setResultAndType(true, false);
-    InstructionDesc[OpTypeEvent].setResultAndType(true, false);
-    InstructionDesc[OpTypeDeviceEvent].setResultAndType(true, false);
-    InstructionDesc[OpTypeReserveId].setResultAndType(true, false);
-    InstructionDesc[OpTypeQueue].setResultAndType(true, false);
-    InstructionDesc[OpTypePipe].setResultAndType(true, false);
-    InstructionDesc[OpFunctionEnd].setResultAndType(false, false);
-    InstructionDesc[OpStore].setResultAndType(false, false);
-    InstructionDesc[OpImageWrite].setResultAndType(false, false);
-    InstructionDesc[OpDecorationGroup].setResultAndType(true, false);
-    InstructionDesc[OpDecorate].setResultAndType(false, false);
-    InstructionDesc[OpDecorateId].setResultAndType(false, false);
-    InstructionDesc[OpDecorateStringGOOGLE].setResultAndType(false, false);
-    InstructionDesc[OpMemberDecorate].setResultAndType(false, false);
-    InstructionDesc[OpMemberDecorateStringGOOGLE].setResultAndType(false, false);
-    InstructionDesc[OpGroupDecorate].setResultAndType(false, false);
-    InstructionDesc[OpGroupMemberDecorate].setResultAndType(false, false);
-    InstructionDesc[OpName].setResultAndType(false, false);
-    InstructionDesc[OpMemberName].setResultAndType(false, false);
-    InstructionDesc[OpString].setResultAndType(true, false);
-    InstructionDesc[OpLine].setResultAndType(false, false);
-    InstructionDesc[OpNoLine].setResultAndType(false, false);
-    InstructionDesc[OpCopyMemory].setResultAndType(false, false);
-    InstructionDesc[OpCopyMemorySized].setResultAndType(false, false);
-    InstructionDesc[OpEmitVertex].setResultAndType(false, false);
-    InstructionDesc[OpEndPrimitive].setResultAndType(false, false);
-    InstructionDesc[OpEmitStreamVertex].setResultAndType(false, false);
-    InstructionDesc[OpEndStreamPrimitive].setResultAndType(false, false);
-    InstructionDesc[OpControlBarrier].setResultAndType(false, false);
-    InstructionDesc[OpMemoryBarrier].setResultAndType(false, false);
-    InstructionDesc[OpAtomicStore].setResultAndType(false, false);
-    InstructionDesc[OpLoopMerge].setResultAndType(false, false);
-    InstructionDesc[OpSelectionMerge].setResultAndType(false, false);
-    InstructionDesc[OpLabel].setResultAndType(true, false);
-    InstructionDesc[OpBranch].setResultAndType(false, false);
-    InstructionDesc[OpBranchConditional].setResultAndType(false, false);
-    InstructionDesc[OpSwitch].setResultAndType(false, false);
-    InstructionDesc[OpKill].setResultAndType(false, false);
-    InstructionDesc[OpTerminateInvocation].setResultAndType(false, false);
-    InstructionDesc[OpReturn].setResultAndType(false, false);
-    InstructionDesc[OpReturnValue].setResultAndType(false, false);
-    InstructionDesc[OpUnreachable].setResultAndType(false, false);
-    InstructionDesc[OpLifetimeStart].setResultAndType(false, false);
-    InstructionDesc[OpLifetimeStop].setResultAndType(false, false);
-    InstructionDesc[OpCommitReadPipe].setResultAndType(false, false);
-    InstructionDesc[OpCommitWritePipe].setResultAndType(false, false);
-    InstructionDesc[OpGroupCommitWritePipe].setResultAndType(false, false);
-    InstructionDesc[OpGroupCommitReadPipe].setResultAndType(false, false);
-    InstructionDesc[OpCaptureEventProfilingInfo].setResultAndType(false, false);
-    InstructionDesc[OpSetUserEventStatus].setResultAndType(false, false);
-    InstructionDesc[OpRetainEvent].setResultAndType(false, false);
-    InstructionDesc[OpReleaseEvent].setResultAndType(false, false);
-    InstructionDesc[OpGroupWaitEvents].setResultAndType(false, false);
-    InstructionDesc[OpAtomicFlagClear].setResultAndType(false, false);
-    InstructionDesc[OpModuleProcessed].setResultAndType(false, false);
-    InstructionDesc[OpTypeCooperativeMatrixNV].setResultAndType(true, false);
-    InstructionDesc[OpCooperativeMatrixStoreNV].setResultAndType(false, false);
-    InstructionDesc[OpBeginInvocationInterlockEXT].setResultAndType(false, false);
-    InstructionDesc[OpEndInvocationInterlockEXT].setResultAndType(false, false);
+        InstructionDesc[OpNop].setResultAndType(false, false);
+        InstructionDesc[OpSource].setResultAndType(false, false);
+        InstructionDesc[OpSourceContinued].setResultAndType(false, false);
+        InstructionDesc[OpSourceExtension].setResultAndType(false, false);
+        InstructionDesc[OpExtension].setResultAndType(false, false);
+        InstructionDesc[OpExtInstImport].setResultAndType(true, false);
+        InstructionDesc[OpCapability].setResultAndType(false, false);
+        InstructionDesc[OpMemoryModel].setResultAndType(false, false);
+        InstructionDesc[OpEntryPoint].setResultAndType(false, false);
+        InstructionDesc[OpExecutionMode].setResultAndType(false, false);
+        InstructionDesc[OpExecutionModeId].setResultAndType(false, false);
+        InstructionDesc[OpTypeVoid].setResultAndType(true, false);
+        InstructionDesc[OpTypeBool].setResultAndType(true, false);
+        InstructionDesc[OpTypeInt].setResultAndType(true, false);
+        InstructionDesc[OpTypeFloat].setResultAndType(true, false);
+        InstructionDesc[OpTypeVector].setResultAndType(true, false);
+        InstructionDesc[OpTypeMatrix].setResultAndType(true, false);
+        InstructionDesc[OpTypeImage].setResultAndType(true, false);
+        InstructionDesc[OpTypeSampler].setResultAndType(true, false);
+        InstructionDesc[OpTypeSampledImage].setResultAndType(true, false);
+        InstructionDesc[OpTypeArray].setResultAndType(true, false);
+        InstructionDesc[OpTypeRuntimeArray].setResultAndType(true, false);
+        InstructionDesc[OpTypeStruct].setResultAndType(true, false);
+        InstructionDesc[OpTypeOpaque].setResultAndType(true, false);
+        InstructionDesc[OpTypePointer].setResultAndType(true, false);
+        InstructionDesc[OpTypeForwardPointer].setResultAndType(false, false);
+        InstructionDesc[OpTypeFunction].setResultAndType(true, false);
+        InstructionDesc[OpTypeEvent].setResultAndType(true, false);
+        InstructionDesc[OpTypeDeviceEvent].setResultAndType(true, false);
+        InstructionDesc[OpTypeReserveId].setResultAndType(true, false);
+        InstructionDesc[OpTypeQueue].setResultAndType(true, false);
+        InstructionDesc[OpTypePipe].setResultAndType(true, false);
+        InstructionDesc[OpFunctionEnd].setResultAndType(false, false);
+        InstructionDesc[OpStore].setResultAndType(false, false);
+        InstructionDesc[OpImageWrite].setResultAndType(false, false);
+        InstructionDesc[OpDecorationGroup].setResultAndType(true, false);
+        InstructionDesc[OpDecorate].setResultAndType(false, false);
+        InstructionDesc[OpDecorateId].setResultAndType(false, false);
+        InstructionDesc[OpDecorateStringGOOGLE].setResultAndType(false, false);
+        InstructionDesc[OpMemberDecorate].setResultAndType(false, false);
+        InstructionDesc[OpMemberDecorateStringGOOGLE].setResultAndType(false, false);
+        InstructionDesc[OpGroupDecorate].setResultAndType(false, false);
+        InstructionDesc[OpGroupMemberDecorate].setResultAndType(false, false);
+        InstructionDesc[OpName].setResultAndType(false, false);
+        InstructionDesc[OpMemberName].setResultAndType(false, false);
+        InstructionDesc[OpString].setResultAndType(true, false);
+        InstructionDesc[OpLine].setResultAndType(false, false);
+        InstructionDesc[OpNoLine].setResultAndType(false, false);
+        InstructionDesc[OpCopyMemory].setResultAndType(false, false);
+        InstructionDesc[OpCopyMemorySized].setResultAndType(false, false);
+        InstructionDesc[OpEmitVertex].setResultAndType(false, false);
+        InstructionDesc[OpEndPrimitive].setResultAndType(false, false);
+        InstructionDesc[OpEmitStreamVertex].setResultAndType(false, false);
+        InstructionDesc[OpEndStreamPrimitive].setResultAndType(false, false);
+        InstructionDesc[OpControlBarrier].setResultAndType(false, false);
+        InstructionDesc[OpMemoryBarrier].setResultAndType(false, false);
+        InstructionDesc[OpAtomicStore].setResultAndType(false, false);
+        InstructionDesc[OpLoopMerge].setResultAndType(false, false);
+        InstructionDesc[OpSelectionMerge].setResultAndType(false, false);
+        InstructionDesc[OpLabel].setResultAndType(true, false);
+        InstructionDesc[OpBranch].setResultAndType(false, false);
+        InstructionDesc[OpBranchConditional].setResultAndType(false, false);
+        InstructionDesc[OpSwitch].setResultAndType(false, false);
+        InstructionDesc[OpKill].setResultAndType(false, false);
+        InstructionDesc[OpTerminateInvocation].setResultAndType(false, false);
+        InstructionDesc[OpReturn].setResultAndType(false, false);
+        InstructionDesc[OpReturnValue].setResultAndType(false, false);
+        InstructionDesc[OpUnreachable].setResultAndType(false, false);
+        InstructionDesc[OpLifetimeStart].setResultAndType(false, false);
+        InstructionDesc[OpLifetimeStop].setResultAndType(false, false);
+        InstructionDesc[OpCommitReadPipe].setResultAndType(false, false);
+        InstructionDesc[OpCommitWritePipe].setResultAndType(false, false);
+        InstructionDesc[OpGroupCommitWritePipe].setResultAndType(false, false);
+        InstructionDesc[OpGroupCommitReadPipe].setResultAndType(false, false);
+        InstructionDesc[OpCaptureEventProfilingInfo].setResultAndType(false, false);
+        InstructionDesc[OpSetUserEventStatus].setResultAndType(false, false);
+        InstructionDesc[OpRetainEvent].setResultAndType(false, false);
+        InstructionDesc[OpReleaseEvent].setResultAndType(false, false);
+        InstructionDesc[OpGroupWaitEvents].setResultAndType(false, false);
+        InstructionDesc[OpAtomicFlagClear].setResultAndType(false, false);
+        InstructionDesc[OpModuleProcessed].setResultAndType(false, false);
+        InstructionDesc[OpTypeCooperativeMatrixNV].setResultAndType(true, false);
+        InstructionDesc[OpCooperativeMatrixStoreNV].setResultAndType(false, false);
+        InstructionDesc[OpTypeCooperativeMatrixKHR].setResultAndType(true, false);
+        InstructionDesc[OpCooperativeMatrixStoreKHR].setResultAndType(false, false);
+        InstructionDesc[OpBeginInvocationInterlockEXT].setResultAndType(false, false);
+        InstructionDesc[OpEndInvocationInterlockEXT].setResultAndType(false, false);
 
-    // Specific additional context-dependent operands
+        // Specific additional context-dependent operands
 
-    ExecutionModeOperands[ExecutionModeInvocations].push(OperandLiteralNumber, "'Number of <<Invocation,invocations>>'");
+        ExecutionModeOperands[ExecutionModeInvocations].push(OperandLiteralNumber, "'Number of <<Invocation,invocations>>'");
 
-    ExecutionModeOperands[ExecutionModeLocalSize].push(OperandLiteralNumber, "'x size'");
-    ExecutionModeOperands[ExecutionModeLocalSize].push(OperandLiteralNumber, "'y size'");
-    ExecutionModeOperands[ExecutionModeLocalSize].push(OperandLiteralNumber, "'z size'");
+        ExecutionModeOperands[ExecutionModeLocalSize].push(OperandLiteralNumber, "'x size'");
+        ExecutionModeOperands[ExecutionModeLocalSize].push(OperandLiteralNumber, "'y size'");
+        ExecutionModeOperands[ExecutionModeLocalSize].push(OperandLiteralNumber, "'z size'");
 
-    ExecutionModeOperands[ExecutionModeLocalSizeHint].push(OperandLiteralNumber, "'x size'");
-    ExecutionModeOperands[ExecutionModeLocalSizeHint].push(OperandLiteralNumber, "'y size'");
-    ExecutionModeOperands[ExecutionModeLocalSizeHint].push(OperandLiteralNumber, "'z size'");
+        ExecutionModeOperands[ExecutionModeLocalSizeHint].push(OperandLiteralNumber, "'x size'");
+        ExecutionModeOperands[ExecutionModeLocalSizeHint].push(OperandLiteralNumber, "'y size'");
+        ExecutionModeOperands[ExecutionModeLocalSizeHint].push(OperandLiteralNumber, "'z size'");
 
-    ExecutionModeOperands[ExecutionModeOutputVertices].push(OperandLiteralNumber, "'Vertex count'");
-    ExecutionModeOperands[ExecutionModeVecTypeHint].push(OperandLiteralNumber, "'Vector type'");
+        ExecutionModeOperands[ExecutionModeOutputVertices].push(OperandLiteralNumber, "'Vertex count'");
+        ExecutionModeOperands[ExecutionModeVecTypeHint].push(OperandLiteralNumber, "'Vector type'");
 
-    DecorationOperands[DecorationStream].push(OperandLiteralNumber, "'Stream Number'");
-    DecorationOperands[DecorationLocation].push(OperandLiteralNumber, "'Location'");
-    DecorationOperands[DecorationComponent].push(OperandLiteralNumber, "'Component'");
-    DecorationOperands[DecorationIndex].push(OperandLiteralNumber, "'Index'");
-    DecorationOperands[DecorationBinding].push(OperandLiteralNumber, "'Binding Point'");
-    DecorationOperands[DecorationDescriptorSet].push(OperandLiteralNumber, "'Descriptor Set'");
-    DecorationOperands[DecorationOffset].push(OperandLiteralNumber, "'Byte Offset'");
-    DecorationOperands[DecorationXfbBuffer].push(OperandLiteralNumber, "'XFB Buffer Number'");
-    DecorationOperands[DecorationXfbStride].push(OperandLiteralNumber, "'XFB Stride'");
-    DecorationOperands[DecorationArrayStride].push(OperandLiteralNumber, "'Array Stride'");
-    DecorationOperands[DecorationMatrixStride].push(OperandLiteralNumber, "'Matrix Stride'");
-    DecorationOperands[DecorationBuiltIn].push(OperandLiteralNumber, "See <<BuiltIn,*BuiltIn*>>");
-    DecorationOperands[DecorationFPRoundingMode].push(OperandFPRoundingMode, "'Floating-Point Rounding Mode'");
-    DecorationOperands[DecorationFPFastMathMode].push(OperandFPFastMath, "'Fast-Math Mode'");
-    DecorationOperands[DecorationLinkageAttributes].push(OperandLiteralString, "'Name'");
-    DecorationOperands[DecorationLinkageAttributes].push(OperandLinkageType, "'Linkage Type'");
-    DecorationOperands[DecorationFuncParamAttr].push(OperandFuncParamAttr, "'Function Parameter Attribute'");
-    DecorationOperands[DecorationSpecId].push(OperandLiteralNumber, "'Specialization Constant ID'");
-    DecorationOperands[DecorationInputAttachmentIndex].push(OperandLiteralNumber, "'Attachment Index'");
-    DecorationOperands[DecorationAlignment].push(OperandLiteralNumber, "'Alignment'");
+        DecorationOperands[DecorationStream].push(OperandLiteralNumber, "'Stream Number'");
+        DecorationOperands[DecorationLocation].push(OperandLiteralNumber, "'Location'");
+        DecorationOperands[DecorationComponent].push(OperandLiteralNumber, "'Component'");
+        DecorationOperands[DecorationIndex].push(OperandLiteralNumber, "'Index'");
+        DecorationOperands[DecorationBinding].push(OperandLiteralNumber, "'Binding Point'");
+        DecorationOperands[DecorationDescriptorSet].push(OperandLiteralNumber, "'Descriptor Set'");
+        DecorationOperands[DecorationOffset].push(OperandLiteralNumber, "'Byte Offset'");
+        DecorationOperands[DecorationXfbBuffer].push(OperandLiteralNumber, "'XFB Buffer Number'");
+        DecorationOperands[DecorationXfbStride].push(OperandLiteralNumber, "'XFB Stride'");
+        DecorationOperands[DecorationArrayStride].push(OperandLiteralNumber, "'Array Stride'");
+        DecorationOperands[DecorationMatrixStride].push(OperandLiteralNumber, "'Matrix Stride'");
+        DecorationOperands[DecorationBuiltIn].push(OperandLiteralNumber, "See <<BuiltIn,*BuiltIn*>>");
+        DecorationOperands[DecorationFPRoundingMode].push(OperandFPRoundingMode, "'Floating-Point Rounding Mode'");
+        DecorationOperands[DecorationFPFastMathMode].push(OperandFPFastMath, "'Fast-Math Mode'");
+        DecorationOperands[DecorationLinkageAttributes].push(OperandLiteralString, "'Name'");
+        DecorationOperands[DecorationLinkageAttributes].push(OperandLinkageType, "'Linkage Type'");
+        DecorationOperands[DecorationFuncParamAttr].push(OperandFuncParamAttr, "'Function Parameter Attribute'");
+        DecorationOperands[DecorationSpecId].push(OperandLiteralNumber, "'Specialization Constant ID'");
+        DecorationOperands[DecorationInputAttachmentIndex].push(OperandLiteralNumber, "'Attachment Index'");
+        DecorationOperands[DecorationAlignment].push(OperandLiteralNumber, "'Alignment'");
 
-    OperandClassParams[OperandSource].set(0, SourceString, 0);
-    OperandClassParams[OperandExecutionModel].set(0, ExecutionModelString, nullptr);
-    OperandClassParams[OperandAddressing].set(0, AddressingString, nullptr);
-    OperandClassParams[OperandMemory].set(0, MemoryString, nullptr);
-    OperandClassParams[OperandExecutionMode].set(ExecutionModeCeiling, ExecutionModeString, ExecutionModeParams);
-    OperandClassParams[OperandExecutionMode].setOperands(ExecutionModeOperands);
-    OperandClassParams[OperandStorage].set(0, StorageClassString, nullptr);
-    OperandClassParams[OperandDimensionality].set(0, DimensionString, nullptr);
-    OperandClassParams[OperandSamplerAddressingMode].set(0, SamplerAddressingModeString, nullptr);
-    OperandClassParams[OperandSamplerFilterMode].set(0, SamplerFilterModeString, nullptr);
-    OperandClassParams[OperandSamplerImageFormat].set(0, ImageFormatString, nullptr);
-    OperandClassParams[OperandImageChannelOrder].set(0, ImageChannelOrderString, nullptr);
-    OperandClassParams[OperandImageChannelDataType].set(0, ImageChannelDataTypeString, nullptr);
-    OperandClassParams[OperandImageOperands].set(ImageOperandsCeiling, ImageOperandsString, ImageOperandsParams, true);
-    OperandClassParams[OperandFPFastMath].set(0, FPFastMathString, nullptr, true);
-    OperandClassParams[OperandFPRoundingMode].set(0, FPRoundingModeString, nullptr);
-    OperandClassParams[OperandLinkageType].set(0, LinkageTypeString, nullptr);
-    OperandClassParams[OperandFuncParamAttr].set(0, FuncParamAttrString, nullptr);
-    OperandClassParams[OperandAccessQualifier].set(0, AccessQualifierString, nullptr);
-    OperandClassParams[OperandDecoration].set(DecorationCeiling, DecorationString, DecorationParams);
-    OperandClassParams[OperandDecoration].setOperands(DecorationOperands);
-    OperandClassParams[OperandBuiltIn].set(0, BuiltInString, nullptr);
-    OperandClassParams[OperandSelect].set(SelectControlCeiling, SelectControlString, SelectionControlParams, true);
-    OperandClassParams[OperandLoop].set(LoopControlCeiling, LoopControlString, LoopControlParams, true);
-    OperandClassParams[OperandFunction].set(FunctionControlCeiling, FunctionControlString, FunctionControlParams, true);
-    OperandClassParams[OperandMemorySemantics].set(0, MemorySemanticsString, nullptr, true);
-    OperandClassParams[OperandMemoryAccess].set(MemoryAccessCeiling, MemoryAccessString, MemoryAccessParams, true);
-    OperandClassParams[OperandScope].set(0, ScopeString, nullptr);
-    OperandClassParams[OperandGroupOperation].set(0, GroupOperationString, nullptr);
-    OperandClassParams[OperandKernelEnqueueFlags].set(0, KernelEnqueueFlagsString, nullptr);
-    OperandClassParams[OperandKernelProfilingInfo].set(0, KernelProfilingInfoString, nullptr, true);
-    OperandClassParams[OperandCapability].set(0, CapabilityString, nullptr);
-    OperandClassParams[OperandOpcode].set(OpCodeMask + 1, OpcodeString, 0);
+        OperandClassParams[OperandSource].set(0, SourceString, nullptr);
+        OperandClassParams[OperandExecutionModel].set(0, ExecutionModelString, nullptr);
+        OperandClassParams[OperandAddressing].set(0, AddressingString, nullptr);
+        OperandClassParams[OperandMemory].set(0, MemoryString, nullptr);
+        OperandClassParams[OperandExecutionMode].set(ExecutionModeCeiling, ExecutionModeString, ExecutionModeParams);
+        OperandClassParams[OperandExecutionMode].setOperands(ExecutionModeOperands);
+        OperandClassParams[OperandStorage].set(0, StorageClassString, nullptr);
+        OperandClassParams[OperandDimensionality].set(0, DimensionString, nullptr);
+        OperandClassParams[OperandSamplerAddressingMode].set(0, SamplerAddressingModeString, nullptr);
+        OperandClassParams[OperandSamplerFilterMode].set(0, SamplerFilterModeString, nullptr);
+        OperandClassParams[OperandSamplerImageFormat].set(0, ImageFormatString, nullptr);
+        OperandClassParams[OperandImageChannelOrder].set(0, ImageChannelOrderString, nullptr);
+        OperandClassParams[OperandImageChannelDataType].set(0, ImageChannelDataTypeString, nullptr);
+        OperandClassParams[OperandImageOperands].set(ImageOperandsCeiling, ImageOperandsString, ImageOperandsParams, true);
+        OperandClassParams[OperandFPFastMath].set(0, FPFastMathString, nullptr, true);
+        OperandClassParams[OperandFPRoundingMode].set(0, FPRoundingModeString, nullptr);
+        OperandClassParams[OperandLinkageType].set(0, LinkageTypeString, nullptr);
+        OperandClassParams[OperandFuncParamAttr].set(0, FuncParamAttrString, nullptr);
+        OperandClassParams[OperandAccessQualifier].set(0, AccessQualifierString, nullptr);
+        OperandClassParams[OperandDecoration].set(DecorationCeiling, DecorationString, DecorationParams);
+        OperandClassParams[OperandDecoration].setOperands(DecorationOperands);
+        OperandClassParams[OperandBuiltIn].set(0, BuiltInString, nullptr);
+        OperandClassParams[OperandSelect].set(SelectControlCeiling, SelectControlString, SelectionControlParams, true);
+        OperandClassParams[OperandLoop].set(LoopControlCeiling, LoopControlString, LoopControlParams, true);
+        OperandClassParams[OperandFunction].set(FunctionControlCeiling, FunctionControlString, FunctionControlParams, true);
+        OperandClassParams[OperandMemorySemantics].set(0, MemorySemanticsString, nullptr, true);
+        OperandClassParams[OperandMemoryAccess].set(MemoryAccessCeiling, MemoryAccessString, MemoryAccessParams, true);
+        OperandClassParams[OperandScope].set(0, ScopeString, nullptr);
+        OperandClassParams[OperandGroupOperation].set(0, GroupOperationString, nullptr);
+        OperandClassParams[OperandKernelEnqueueFlags].set(0, KernelEnqueueFlagsString, nullptr);
+        OperandClassParams[OperandKernelProfilingInfo].set(0, KernelProfilingInfoString, nullptr, true);
+        OperandClassParams[OperandCapability].set(0, CapabilityString, nullptr);
+        OperandClassParams[OperandCooperativeMatrixOperands].set(CooperativeMatrixOperandsCeiling, CooperativeMatrixOperandsString, CooperativeMatrixOperandsParams, true);
+        OperandClassParams[OperandOpcode].set(OpCodeMask + 1, OpcodeString, nullptr);
 
-    // set name of operator, an initial set of <id> style operands, and the description
+        // set name of operator, an initial set of <id> style operands, and the description
 
-    InstructionDesc[OpSource].operands.push(OperandSource, "");
-    InstructionDesc[OpSource].operands.push(OperandLiteralNumber, "'Version'");
-    InstructionDesc[OpSource].operands.push(OperandId, "'File'", true);
-    InstructionDesc[OpSource].operands.push(OperandLiteralString, "'Source'", true);
+        InstructionDesc[OpSource].operands.push(OperandSource, "");
+        InstructionDesc[OpSource].operands.push(OperandLiteralNumber, "'Version'");
+        InstructionDesc[OpSource].operands.push(OperandId, "'File'", true);
+        InstructionDesc[OpSource].operands.push(OperandLiteralString, "'Source'", true);
 
-    InstructionDesc[OpSourceContinued].operands.push(OperandLiteralString, "'Continued Source'");
+        InstructionDesc[OpSourceContinued].operands.push(OperandLiteralString, "'Continued Source'");
 
-    InstructionDesc[OpSourceExtension].operands.push(OperandLiteralString, "'Extension'");
+        InstructionDesc[OpSourceExtension].operands.push(OperandLiteralString, "'Extension'");
 
-    InstructionDesc[OpName].operands.push(OperandId, "'Target'");
-    InstructionDesc[OpName].operands.push(OperandLiteralString, "'Name'");
+        InstructionDesc[OpName].operands.push(OperandId, "'Target'");
+        InstructionDesc[OpName].operands.push(OperandLiteralString, "'Name'");
 
-    InstructionDesc[OpMemberName].operands.push(OperandId, "'Type'");
-    InstructionDesc[OpMemberName].operands.push(OperandLiteralNumber, "'Member'");
-    InstructionDesc[OpMemberName].operands.push(OperandLiteralString, "'Name'");
+        InstructionDesc[OpMemberName].operands.push(OperandId, "'Type'");
+        InstructionDesc[OpMemberName].operands.push(OperandLiteralNumber, "'Member'");
+        InstructionDesc[OpMemberName].operands.push(OperandLiteralString, "'Name'");
 
-    InstructionDesc[OpString].operands.push(OperandLiteralString, "'String'");
+        InstructionDesc[OpString].operands.push(OperandLiteralString, "'String'");
 
-    InstructionDesc[OpLine].operands.push(OperandId, "'File'");
-    InstructionDesc[OpLine].operands.push(OperandLiteralNumber, "'Line'");
-    InstructionDesc[OpLine].operands.push(OperandLiteralNumber, "'Column'");
+        InstructionDesc[OpLine].operands.push(OperandId, "'File'");
+        InstructionDesc[OpLine].operands.push(OperandLiteralNumber, "'Line'");
+        InstructionDesc[OpLine].operands.push(OperandLiteralNumber, "'Column'");
 
-    InstructionDesc[OpExtension].operands.push(OperandLiteralString, "'Name'");
+        InstructionDesc[OpExtension].operands.push(OperandLiteralString, "'Name'");
 
-    InstructionDesc[OpExtInstImport].operands.push(OperandLiteralString, "'Name'");
+        InstructionDesc[OpExtInstImport].operands.push(OperandLiteralString, "'Name'");
 
-    InstructionDesc[OpCapability].operands.push(OperandCapability, "'Capability'");
+        InstructionDesc[OpCapability].operands.push(OperandCapability, "'Capability'");
 
-    InstructionDesc[OpMemoryModel].operands.push(OperandAddressing, "");
-    InstructionDesc[OpMemoryModel].operands.push(OperandMemory, "");
+        InstructionDesc[OpMemoryModel].operands.push(OperandAddressing, "");
+        InstructionDesc[OpMemoryModel].operands.push(OperandMemory, "");
 
-    InstructionDesc[OpEntryPoint].operands.push(OperandExecutionModel, "");
-    InstructionDesc[OpEntryPoint].operands.push(OperandId, "'Entry Point'");
-    InstructionDesc[OpEntryPoint].operands.push(OperandLiteralString, "'Name'");
-    InstructionDesc[OpEntryPoint].operands.push(OperandVariableIds, "'Interface'");
+        InstructionDesc[OpEntryPoint].operands.push(OperandExecutionModel, "");
+        InstructionDesc[OpEntryPoint].operands.push(OperandId, "'Entry Point'");
+        InstructionDesc[OpEntryPoint].operands.push(OperandLiteralString, "'Name'");
+        InstructionDesc[OpEntryPoint].operands.push(OperandVariableIds, "'Interface'");
 
-    InstructionDesc[OpExecutionMode].operands.push(OperandId, "'Entry Point'");
-    InstructionDesc[OpExecutionMode].operands.push(OperandExecutionMode, "'Mode'");
-    InstructionDesc[OpExecutionMode].operands.push(OperandOptionalLiteral, "See <<Execution_Mode,Execution Mode>>");
+        InstructionDesc[OpExecutionMode].operands.push(OperandId, "'Entry Point'");
+        InstructionDesc[OpExecutionMode].operands.push(OperandExecutionMode, "'Mode'");
+        InstructionDesc[OpExecutionMode].operands.push(OperandOptionalLiteral, "See <<Execution_Mode,Execution Mode>>");
 
-    InstructionDesc[OpExecutionModeId].operands.push(OperandId, "'Entry Point'");
-    InstructionDesc[OpExecutionModeId].operands.push(OperandExecutionMode, "'Mode'");
-    InstructionDesc[OpExecutionModeId].operands.push(OperandVariableIds, "See <<Execution_Mode,Execution Mode>>");
+        InstructionDesc[OpExecutionModeId].operands.push(OperandId, "'Entry Point'");
+        InstructionDesc[OpExecutionModeId].operands.push(OperandExecutionMode, "'Mode'");
+        InstructionDesc[OpExecutionModeId].operands.push(OperandVariableIds, "See <<Execution_Mode,Execution Mode>>");
 
-    InstructionDesc[OpTypeInt].operands.push(OperandLiteralNumber, "'Width'");
-    InstructionDesc[OpTypeInt].operands.push(OperandLiteralNumber, "'Signedness'");
+        InstructionDesc[OpTypeInt].operands.push(OperandLiteralNumber, "'Width'");
+        InstructionDesc[OpTypeInt].operands.push(OperandLiteralNumber, "'Signedness'");
 
-    InstructionDesc[OpTypeFloat].operands.push(OperandLiteralNumber, "'Width'");
+        InstructionDesc[OpTypeFloat].operands.push(OperandLiteralNumber, "'Width'");
 
-    InstructionDesc[OpTypeVector].operands.push(OperandId, "'Component Type'");
-    InstructionDesc[OpTypeVector].operands.push(OperandLiteralNumber, "'Component Count'");
+        InstructionDesc[OpTypeVector].operands.push(OperandId, "'Component Type'");
+        InstructionDesc[OpTypeVector].operands.push(OperandLiteralNumber, "'Component Count'");
 
-    InstructionDesc[OpTypeMatrix].operands.push(OperandId, "'Column Type'");
-    InstructionDesc[OpTypeMatrix].operands.push(OperandLiteralNumber, "'Column Count'");
+        InstructionDesc[OpTypeMatrix].operands.push(OperandId, "'Column Type'");
+        InstructionDesc[OpTypeMatrix].operands.push(OperandLiteralNumber, "'Column Count'");
 
-    InstructionDesc[OpTypeImage].operands.push(OperandId, "'Sampled Type'");
-    InstructionDesc[OpTypeImage].operands.push(OperandDimensionality, "");
-    InstructionDesc[OpTypeImage].operands.push(OperandLiteralNumber, "'Depth'");
-    InstructionDesc[OpTypeImage].operands.push(OperandLiteralNumber, "'Arrayed'");
-    InstructionDesc[OpTypeImage].operands.push(OperandLiteralNumber, "'MS'");
-    InstructionDesc[OpTypeImage].operands.push(OperandLiteralNumber, "'Sampled'");
-    InstructionDesc[OpTypeImage].operands.push(OperandSamplerImageFormat, "");
-    InstructionDesc[OpTypeImage].operands.push(OperandAccessQualifier, "", true);
+        InstructionDesc[OpTypeImage].operands.push(OperandId, "'Sampled Type'");
+        InstructionDesc[OpTypeImage].operands.push(OperandDimensionality, "");
+        InstructionDesc[OpTypeImage].operands.push(OperandLiteralNumber, "'Depth'");
+        InstructionDesc[OpTypeImage].operands.push(OperandLiteralNumber, "'Arrayed'");
+        InstructionDesc[OpTypeImage].operands.push(OperandLiteralNumber, "'MS'");
+        InstructionDesc[OpTypeImage].operands.push(OperandLiteralNumber, "'Sampled'");
+        InstructionDesc[OpTypeImage].operands.push(OperandSamplerImageFormat, "");
+        InstructionDesc[OpTypeImage].operands.push(OperandAccessQualifier, "", true);
 
-    InstructionDesc[OpTypeSampledImage].operands.push(OperandId, "'Image Type'");
+        InstructionDesc[OpTypeSampledImage].operands.push(OperandId, "'Image Type'");
 
-    InstructionDesc[OpTypeArray].operands.push(OperandId, "'Element Type'");
-    InstructionDesc[OpTypeArray].operands.push(OperandId, "'Length'");
+        InstructionDesc[OpTypeArray].operands.push(OperandId, "'Element Type'");
+        InstructionDesc[OpTypeArray].operands.push(OperandId, "'Length'");
 
-    InstructionDesc[OpTypeRuntimeArray].operands.push(OperandId, "'Element Type'");
+        InstructionDesc[OpTypeRuntimeArray].operands.push(OperandId, "'Element Type'");
 
-    InstructionDesc[OpTypeStruct].operands.push(OperandVariableIds, "'Member 0 type', +\n'member 1 type', +\n...");
+        InstructionDesc[OpTypeStruct].operands.push(OperandVariableIds, "'Member 0 type', +\n'member 1 type', +\n...");
 
-    InstructionDesc[OpTypeOpaque].operands.push(OperandLiteralString, "The name of the opaque type.");
+        InstructionDesc[OpTypeOpaque].operands.push(OperandLiteralString, "The name of the opaque type.");
 
-    InstructionDesc[OpTypePointer].operands.push(OperandStorage, "");
-    InstructionDesc[OpTypePointer].operands.push(OperandId, "'Type'");
+        InstructionDesc[OpTypePointer].operands.push(OperandStorage, "");
+        InstructionDesc[OpTypePointer].operands.push(OperandId, "'Type'");
 
-    InstructionDesc[OpTypeForwardPointer].operands.push(OperandId, "'Pointer Type'");
-    InstructionDesc[OpTypeForwardPointer].operands.push(OperandStorage, "");
+        InstructionDesc[OpTypeForwardPointer].operands.push(OperandId, "'Pointer Type'");
+        InstructionDesc[OpTypeForwardPointer].operands.push(OperandStorage, "");
 
-    InstructionDesc[OpTypePipe].operands.push(OperandAccessQualifier, "'Qualifier'");
+        InstructionDesc[OpTypePipe].operands.push(OperandAccessQualifier, "'Qualifier'");
 
-    InstructionDesc[OpTypeFunction].operands.push(OperandId, "'Return Type'");
-    InstructionDesc[OpTypeFunction].operands.push(OperandVariableIds, "'Parameter 0 Type', +\n'Parameter 1 Type', +\n...");
+        InstructionDesc[OpTypeFunction].operands.push(OperandId, "'Return Type'");
+        InstructionDesc[OpTypeFunction].operands.push(OperandVariableIds, "'Parameter 0 Type', +\n'Parameter 1 Type', +\n...");
 
-    InstructionDesc[OpConstant].operands.push(OperandVariableLiterals, "'Value'");
+        InstructionDesc[OpConstant].operands.push(OperandVariableLiterals, "'Value'");
 
-    InstructionDesc[OpConstantComposite].operands.push(OperandVariableIds, "'Constituents'");
+        InstructionDesc[OpConstantComposite].operands.push(OperandVariableIds, "'Constituents'");
 
-    InstructionDesc[OpConstantSampler].operands.push(OperandSamplerAddressingMode, "");
-    InstructionDesc[OpConstantSampler].operands.push(OperandLiteralNumber, "'Param'");
-    InstructionDesc[OpConstantSampler].operands.push(OperandSamplerFilterMode, "");
+        InstructionDesc[OpConstantSampler].operands.push(OperandSamplerAddressingMode, "");
+        InstructionDesc[OpConstantSampler].operands.push(OperandLiteralNumber, "'Param'");
+        InstructionDesc[OpConstantSampler].operands.push(OperandSamplerFilterMode, "");
 
-    InstructionDesc[OpSpecConstant].operands.push(OperandVariableLiterals, "'Value'");
+        InstructionDesc[OpSpecConstant].operands.push(OperandVariableLiterals, "'Value'");
 
-    InstructionDesc[OpSpecConstantComposite].operands.push(OperandVariableIds, "'Constituents'");
+        InstructionDesc[OpSpecConstantComposite].operands.push(OperandVariableIds, "'Constituents'");
 
-    InstructionDesc[OpSpecConstantOp].operands.push(OperandLiteralNumber, "'Opcode'");
-    InstructionDesc[OpSpecConstantOp].operands.push(OperandVariableIds, "'Operands'");
+        InstructionDesc[OpSpecConstantOp].operands.push(OperandLiteralNumber, "'Opcode'");
+        InstructionDesc[OpSpecConstantOp].operands.push(OperandVariableIds, "'Operands'");
 
-    InstructionDesc[OpVariable].operands.push(OperandStorage, "");
-    InstructionDesc[OpVariable].operands.push(OperandId, "'Initializer'", true);
+        InstructionDesc[OpVariable].operands.push(OperandStorage, "");
+        InstructionDesc[OpVariable].operands.push(OperandId, "'Initializer'", true);
 
-    InstructionDesc[OpFunction].operands.push(OperandFunction, "");
-    InstructionDesc[OpFunction].operands.push(OperandId, "'Function Type'");
+        InstructionDesc[OpFunction].operands.push(OperandFunction, "");
+        InstructionDesc[OpFunction].operands.push(OperandId, "'Function Type'");
 
-    InstructionDesc[OpFunctionCall].operands.push(OperandId, "'Function'");
-    InstructionDesc[OpFunctionCall].operands.push(OperandVariableIds, "'Argument 0', +\n'Argument 1', +\n...");
+        InstructionDesc[OpFunctionCall].operands.push(OperandId, "'Function'");
+        InstructionDesc[OpFunctionCall].operands.push(OperandVariableIds, "'Argument 0', +\n'Argument 1', +\n...");
 
-    InstructionDesc[OpExtInst].operands.push(OperandId, "'Set'");
-    InstructionDesc[OpExtInst].operands.push(OperandLiteralNumber, "'Instruction'");
-    InstructionDesc[OpExtInst].operands.push(OperandVariableIds, "'Operand 1', +\n'Operand 2', +\n...");
+        InstructionDesc[OpExtInst].operands.push(OperandId, "'Set'");
+        InstructionDesc[OpExtInst].operands.push(OperandLiteralNumber, "'Instruction'");
+        InstructionDesc[OpExtInst].operands.push(OperandVariableIds, "'Operand 1', +\n'Operand 2', +\n...");
 
-    InstructionDesc[OpLoad].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpLoad].operands.push(OperandMemoryAccess, "", true);
-    InstructionDesc[OpLoad].operands.push(OperandLiteralNumber, "", true);
-    InstructionDesc[OpLoad].operands.push(OperandId, "", true);
+        InstructionDesc[OpLoad].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpLoad].operands.push(OperandMemoryAccess, "", true);
+        InstructionDesc[OpLoad].operands.push(OperandLiteralNumber, "", true);
+        InstructionDesc[OpLoad].operands.push(OperandId, "", true);
 
-    InstructionDesc[OpStore].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpStore].operands.push(OperandId, "'Object'");
-    InstructionDesc[OpStore].operands.push(OperandMemoryAccess, "", true);
-    InstructionDesc[OpStore].operands.push(OperandLiteralNumber, "", true);
-    InstructionDesc[OpStore].operands.push(OperandId, "", true);
+        InstructionDesc[OpStore].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpStore].operands.push(OperandId, "'Object'");
+        InstructionDesc[OpStore].operands.push(OperandMemoryAccess, "", true);
+        InstructionDesc[OpStore].operands.push(OperandLiteralNumber, "", true);
+        InstructionDesc[OpStore].operands.push(OperandId, "", true);
 
-    InstructionDesc[OpPhi].operands.push(OperandVariableIds, "'Variable, Parent, ...'");
+        InstructionDesc[OpPhi].operands.push(OperandVariableIds, "'Variable, Parent, ...'");
 
-    InstructionDesc[OpDecorate].operands.push(OperandId, "'Target'");
-    InstructionDesc[OpDecorate].operands.push(OperandDecoration, "");
-    InstructionDesc[OpDecorate].operands.push(OperandVariableLiterals, "See <<Decoration,'Decoration'>>.");
+        InstructionDesc[OpDecorate].operands.push(OperandId, "'Target'");
+        InstructionDesc[OpDecorate].operands.push(OperandDecoration, "");
+        InstructionDesc[OpDecorate].operands.push(OperandVariableLiterals, "See <<Decoration,'Decoration'>>.");
 
-    InstructionDesc[OpDecorateId].operands.push(OperandId, "'Target'");
-    InstructionDesc[OpDecorateId].operands.push(OperandDecoration, "");
-    InstructionDesc[OpDecorateId].operands.push(OperandVariableIds, "See <<Decoration,'Decoration'>>.");
+        InstructionDesc[OpDecorateId].operands.push(OperandId, "'Target'");
+        InstructionDesc[OpDecorateId].operands.push(OperandDecoration, "");
+        InstructionDesc[OpDecorateId].operands.push(OperandVariableIds, "See <<Decoration,'Decoration'>>.");
 
-    InstructionDesc[OpDecorateStringGOOGLE].operands.push(OperandId, "'Target'");
-    InstructionDesc[OpDecorateStringGOOGLE].operands.push(OperandDecoration, "");
-    InstructionDesc[OpDecorateStringGOOGLE].operands.push(OperandVariableLiteralStrings, "'Literal Strings'");
+        InstructionDesc[OpDecorateStringGOOGLE].operands.push(OperandId, "'Target'");
+        InstructionDesc[OpDecorateStringGOOGLE].operands.push(OperandDecoration, "");
+        InstructionDesc[OpDecorateStringGOOGLE].operands.push(OperandVariableLiteralStrings, "'Literal Strings'");
 
-    InstructionDesc[OpMemberDecorate].operands.push(OperandId, "'Structure Type'");
-    InstructionDesc[OpMemberDecorate].operands.push(OperandLiteralNumber, "'Member'");
-    InstructionDesc[OpMemberDecorate].operands.push(OperandDecoration, "");
-    InstructionDesc[OpMemberDecorate].operands.push(OperandVariableLiterals, "See <<Decoration,'Decoration'>>.");
+        InstructionDesc[OpMemberDecorate].operands.push(OperandId, "'Structure Type'");
+        InstructionDesc[OpMemberDecorate].operands.push(OperandLiteralNumber, "'Member'");
+        InstructionDesc[OpMemberDecorate].operands.push(OperandDecoration, "");
+        InstructionDesc[OpMemberDecorate].operands.push(OperandVariableLiterals, "See <<Decoration,'Decoration'>>.");
 
-    InstructionDesc[OpMemberDecorateStringGOOGLE].operands.push(OperandId, "'Structure Type'");
-    InstructionDesc[OpMemberDecorateStringGOOGLE].operands.push(OperandLiteralNumber, "'Member'");
-    InstructionDesc[OpMemberDecorateStringGOOGLE].operands.push(OperandDecoration, "");
-    InstructionDesc[OpMemberDecorateStringGOOGLE].operands.push(OperandVariableLiteralStrings, "'Literal Strings'");
+        InstructionDesc[OpMemberDecorateStringGOOGLE].operands.push(OperandId, "'Structure Type'");
+        InstructionDesc[OpMemberDecorateStringGOOGLE].operands.push(OperandLiteralNumber, "'Member'");
+        InstructionDesc[OpMemberDecorateStringGOOGLE].operands.push(OperandDecoration, "");
+        InstructionDesc[OpMemberDecorateStringGOOGLE].operands.push(OperandVariableLiteralStrings, "'Literal Strings'");
 
-    InstructionDesc[OpGroupDecorate].operands.push(OperandId, "'Decoration Group'");
-    InstructionDesc[OpGroupDecorate].operands.push(OperandVariableIds, "'Targets'");
+        InstructionDesc[OpGroupDecorate].operands.push(OperandId, "'Decoration Group'");
+        InstructionDesc[OpGroupDecorate].operands.push(OperandVariableIds, "'Targets'");
 
-    InstructionDesc[OpGroupMemberDecorate].operands.push(OperandId, "'Decoration Group'");
-    InstructionDesc[OpGroupMemberDecorate].operands.push(OperandVariableIdLiteral, "'Targets'");
+        InstructionDesc[OpGroupMemberDecorate].operands.push(OperandId, "'Decoration Group'");
+        InstructionDesc[OpGroupMemberDecorate].operands.push(OperandVariableIdLiteral, "'Targets'");
 
-    InstructionDesc[OpVectorExtractDynamic].operands.push(OperandId, "'Vector'");
-    InstructionDesc[OpVectorExtractDynamic].operands.push(OperandId, "'Index'");
+        InstructionDesc[OpVectorExtractDynamic].operands.push(OperandId, "'Vector'");
+        InstructionDesc[OpVectorExtractDynamic].operands.push(OperandId, "'Index'");
 
-    InstructionDesc[OpVectorInsertDynamic].operands.push(OperandId, "'Vector'");
-    InstructionDesc[OpVectorInsertDynamic].operands.push(OperandId, "'Component'");
-    InstructionDesc[OpVectorInsertDynamic].operands.push(OperandId, "'Index'");
+        InstructionDesc[OpVectorInsertDynamic].operands.push(OperandId, "'Vector'");
+        InstructionDesc[OpVectorInsertDynamic].operands.push(OperandId, "'Component'");
+        InstructionDesc[OpVectorInsertDynamic].operands.push(OperandId, "'Index'");
 
-    InstructionDesc[OpVectorShuffle].operands.push(OperandId, "'Vector 1'");
-    InstructionDesc[OpVectorShuffle].operands.push(OperandId, "'Vector 2'");
-    InstructionDesc[OpVectorShuffle].operands.push(OperandVariableLiterals, "'Components'");
+        InstructionDesc[OpVectorShuffle].operands.push(OperandId, "'Vector 1'");
+        InstructionDesc[OpVectorShuffle].operands.push(OperandId, "'Vector 2'");
+        InstructionDesc[OpVectorShuffle].operands.push(OperandVariableLiterals, "'Components'");
 
-    InstructionDesc[OpCompositeConstruct].operands.push(OperandVariableIds, "'Constituents'");
+        InstructionDesc[OpCompositeConstruct].operands.push(OperandVariableIds, "'Constituents'");
 
-    InstructionDesc[OpCompositeExtract].operands.push(OperandId, "'Composite'");
-    InstructionDesc[OpCompositeExtract].operands.push(OperandVariableLiterals, "'Indexes'");
+        InstructionDesc[OpCompositeExtract].operands.push(OperandId, "'Composite'");
+        InstructionDesc[OpCompositeExtract].operands.push(OperandVariableLiterals, "'Indexes'");
 
-    InstructionDesc[OpCompositeInsert].operands.push(OperandId, "'Object'");
-    InstructionDesc[OpCompositeInsert].operands.push(OperandId, "'Composite'");
-    InstructionDesc[OpCompositeInsert].operands.push(OperandVariableLiterals, "'Indexes'");
+        InstructionDesc[OpCompositeInsert].operands.push(OperandId, "'Object'");
+        InstructionDesc[OpCompositeInsert].operands.push(OperandId, "'Composite'");
+        InstructionDesc[OpCompositeInsert].operands.push(OperandVariableLiterals, "'Indexes'");
 
-    InstructionDesc[OpCopyObject].operands.push(OperandId, "'Operand'");
+        InstructionDesc[OpCopyObject].operands.push(OperandId, "'Operand'");
 
-    InstructionDesc[OpCopyMemory].operands.push(OperandId, "'Target'");
-    InstructionDesc[OpCopyMemory].operands.push(OperandId, "'Source'");
-    InstructionDesc[OpCopyMemory].operands.push(OperandMemoryAccess, "", true);
+        InstructionDesc[OpCopyMemory].operands.push(OperandId, "'Target'");
+        InstructionDesc[OpCopyMemory].operands.push(OperandId, "'Source'");
+        InstructionDesc[OpCopyMemory].operands.push(OperandMemoryAccess, "", true);
 
-    InstructionDesc[OpCopyMemorySized].operands.push(OperandId, "'Target'");
-    InstructionDesc[OpCopyMemorySized].operands.push(OperandId, "'Source'");
-    InstructionDesc[OpCopyMemorySized].operands.push(OperandId, "'Size'");
-    InstructionDesc[OpCopyMemorySized].operands.push(OperandMemoryAccess, "", true);
+        InstructionDesc[OpCopyMemorySized].operands.push(OperandId, "'Target'");
+        InstructionDesc[OpCopyMemorySized].operands.push(OperandId, "'Source'");
+        InstructionDesc[OpCopyMemorySized].operands.push(OperandId, "'Size'");
+        InstructionDesc[OpCopyMemorySized].operands.push(OperandMemoryAccess, "", true);
 
-    InstructionDesc[OpSampledImage].operands.push(OperandId, "'Image'");
-    InstructionDesc[OpSampledImage].operands.push(OperandId, "'Sampler'");
+        InstructionDesc[OpSampledImage].operands.push(OperandId, "'Image'");
+        InstructionDesc[OpSampledImage].operands.push(OperandId, "'Sampler'");
 
-    InstructionDesc[OpImage].operands.push(OperandId, "'Sampled Image'");
+        InstructionDesc[OpImage].operands.push(OperandId, "'Sampled Image'");
 
-    InstructionDesc[OpImageRead].operands.push(OperandId, "'Image'");
-    InstructionDesc[OpImageRead].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageRead].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageRead].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageRead].operands.push(OperandId, "'Image'");
+        InstructionDesc[OpImageRead].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageRead].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageRead].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageWrite].operands.push(OperandId, "'Image'");
-    InstructionDesc[OpImageWrite].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageWrite].operands.push(OperandId, "'Texel'");
-    InstructionDesc[OpImageWrite].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageWrite].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageWrite].operands.push(OperandId, "'Image'");
+        InstructionDesc[OpImageWrite].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageWrite].operands.push(OperandId, "'Texel'");
+        InstructionDesc[OpImageWrite].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageWrite].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageSampleImplicitLod].operands.push(OperandId, "'Sampled Image'");
-    InstructionDesc[OpImageSampleImplicitLod].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageSampleImplicitLod].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageSampleImplicitLod].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageSampleImplicitLod].operands.push(OperandId, "'Sampled Image'");
+        InstructionDesc[OpImageSampleImplicitLod].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageSampleImplicitLod].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageSampleImplicitLod].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageSampleExplicitLod].operands.push(OperandId, "'Sampled Image'");
-    InstructionDesc[OpImageSampleExplicitLod].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageSampleExplicitLod].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageSampleExplicitLod].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageSampleExplicitLod].operands.push(OperandId, "'Sampled Image'");
+        InstructionDesc[OpImageSampleExplicitLod].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageSampleExplicitLod].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageSampleExplicitLod].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandId, "'Sampled Image'");
-    InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandId, "'D~ref~'");
-    InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandId, "'Sampled Image'");
+        InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandId, "'D~ref~'");
+        InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandId, "'Sampled Image'");
-    InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandId, "'D~ref~'");
-    InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandId, "'Sampled Image'");
+        InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandId, "'D~ref~'");
+        InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageSampleProjImplicitLod].operands.push(OperandId, "'Sampled Image'");
-    InstructionDesc[OpImageSampleProjImplicitLod].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageSampleProjImplicitLod].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageSampleProjImplicitLod].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageSampleProjImplicitLod].operands.push(OperandId, "'Sampled Image'");
+        InstructionDesc[OpImageSampleProjImplicitLod].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageSampleProjImplicitLod].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageSampleProjImplicitLod].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageSampleProjExplicitLod].operands.push(OperandId, "'Sampled Image'");
-    InstructionDesc[OpImageSampleProjExplicitLod].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageSampleProjExplicitLod].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageSampleProjExplicitLod].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageSampleProjExplicitLod].operands.push(OperandId, "'Sampled Image'");
+        InstructionDesc[OpImageSampleProjExplicitLod].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageSampleProjExplicitLod].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageSampleProjExplicitLod].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandId, "'Sampled Image'");
-    InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandId, "'D~ref~'");
-    InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandId, "'Sampled Image'");
+        InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandId, "'D~ref~'");
+        InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandId, "'Sampled Image'");
-    InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandId, "'D~ref~'");
-    InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandId, "'Sampled Image'");
+        InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandId, "'D~ref~'");
+        InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageFetch].operands.push(OperandId, "'Image'");
-    InstructionDesc[OpImageFetch].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageFetch].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageFetch].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageFetch].operands.push(OperandId, "'Image'");
+        InstructionDesc[OpImageFetch].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageFetch].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageFetch].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageGather].operands.push(OperandId, "'Sampled Image'");
-    InstructionDesc[OpImageGather].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageGather].operands.push(OperandId, "'Component'");
-    InstructionDesc[OpImageGather].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageGather].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageGather].operands.push(OperandId, "'Sampled Image'");
+        InstructionDesc[OpImageGather].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageGather].operands.push(OperandId, "'Component'");
+        InstructionDesc[OpImageGather].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageGather].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageDrefGather].operands.push(OperandId, "'Sampled Image'");
-    InstructionDesc[OpImageDrefGather].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageDrefGather].operands.push(OperandId, "'D~ref~'");
-    InstructionDesc[OpImageDrefGather].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageDrefGather].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageDrefGather].operands.push(OperandId, "'Sampled Image'");
+        InstructionDesc[OpImageDrefGather].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageDrefGather].operands.push(OperandId, "'D~ref~'");
+        InstructionDesc[OpImageDrefGather].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageDrefGather].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageSparseSampleImplicitLod].operands.push(OperandId, "'Sampled Image'");
-    InstructionDesc[OpImageSparseSampleImplicitLod].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageSparseSampleImplicitLod].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageSparseSampleImplicitLod].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageSparseSampleImplicitLod].operands.push(OperandId, "'Sampled Image'");
+        InstructionDesc[OpImageSparseSampleImplicitLod].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageSparseSampleImplicitLod].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageSparseSampleImplicitLod].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageSparseSampleExplicitLod].operands.push(OperandId, "'Sampled Image'");
-    InstructionDesc[OpImageSparseSampleExplicitLod].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageSparseSampleExplicitLod].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageSparseSampleExplicitLod].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageSparseSampleExplicitLod].operands.push(OperandId, "'Sampled Image'");
+        InstructionDesc[OpImageSparseSampleExplicitLod].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageSparseSampleExplicitLod].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageSparseSampleExplicitLod].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandId, "'Sampled Image'");
-    InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandId, "'D~ref~'");
-    InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandId, "'Sampled Image'");
+        InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandId, "'D~ref~'");
+        InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandId, "'Sampled Image'");
-    InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandId, "'D~ref~'");
-    InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandId, "'Sampled Image'");
+        InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandId, "'D~ref~'");
+        InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageSparseSampleProjImplicitLod].operands.push(OperandId, "'Sampled Image'");
-    InstructionDesc[OpImageSparseSampleProjImplicitLod].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageSparseSampleProjImplicitLod].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageSparseSampleProjImplicitLod].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageSparseSampleProjImplicitLod].operands.push(OperandId, "'Sampled Image'");
+        InstructionDesc[OpImageSparseSampleProjImplicitLod].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageSparseSampleProjImplicitLod].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageSparseSampleProjImplicitLod].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageSparseSampleProjExplicitLod].operands.push(OperandId, "'Sampled Image'");
-    InstructionDesc[OpImageSparseSampleProjExplicitLod].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageSparseSampleProjExplicitLod].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageSparseSampleProjExplicitLod].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageSparseSampleProjExplicitLod].operands.push(OperandId, "'Sampled Image'");
+        InstructionDesc[OpImageSparseSampleProjExplicitLod].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageSparseSampleProjExplicitLod].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageSparseSampleProjExplicitLod].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandId, "'Sampled Image'");
-    InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandId, "'D~ref~'");
-    InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandId, "'Sampled Image'");
+        InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandId, "'D~ref~'");
+        InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandId, "'Sampled Image'");
-    InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandId, "'D~ref~'");
-    InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandId, "'Sampled Image'");
+        InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandId, "'D~ref~'");
+        InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageSparseFetch].operands.push(OperandId, "'Image'");
-    InstructionDesc[OpImageSparseFetch].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageSparseFetch].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageSparseFetch].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageSparseFetch].operands.push(OperandId, "'Image'");
+        InstructionDesc[OpImageSparseFetch].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageSparseFetch].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageSparseFetch].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageSparseGather].operands.push(OperandId, "'Sampled Image'");
-    InstructionDesc[OpImageSparseGather].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageSparseGather].operands.push(OperandId, "'Component'");
-    InstructionDesc[OpImageSparseGather].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageSparseGather].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageSparseGather].operands.push(OperandId, "'Sampled Image'");
+        InstructionDesc[OpImageSparseGather].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageSparseGather].operands.push(OperandId, "'Component'");
+        InstructionDesc[OpImageSparseGather].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageSparseGather].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageSparseDrefGather].operands.push(OperandId, "'Sampled Image'");
-    InstructionDesc[OpImageSparseDrefGather].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageSparseDrefGather].operands.push(OperandId, "'D~ref~'");
-    InstructionDesc[OpImageSparseDrefGather].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageSparseDrefGather].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageSparseDrefGather].operands.push(OperandId, "'Sampled Image'");
+        InstructionDesc[OpImageSparseDrefGather].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageSparseDrefGather].operands.push(OperandId, "'D~ref~'");
+        InstructionDesc[OpImageSparseDrefGather].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageSparseDrefGather].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageSparseRead].operands.push(OperandId, "'Image'");
-    InstructionDesc[OpImageSparseRead].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageSparseRead].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageSparseRead].operands.push(OperandVariableIds, "", true);
+        InstructionDesc[OpImageSparseRead].operands.push(OperandId, "'Image'");
+        InstructionDesc[OpImageSparseRead].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageSparseRead].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageSparseRead].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpImageSparseTexelsResident].operands.push(OperandId, "'Resident Code'");
+        InstructionDesc[OpImageSparseTexelsResident].operands.push(OperandId, "'Resident Code'");
 
-    InstructionDesc[OpImageQuerySizeLod].operands.push(OperandId, "'Image'");
-    InstructionDesc[OpImageQuerySizeLod].operands.push(OperandId, "'Level of Detail'");
+        InstructionDesc[OpImageQuerySizeLod].operands.push(OperandId, "'Image'");
+        InstructionDesc[OpImageQuerySizeLod].operands.push(OperandId, "'Level of Detail'");
 
-    InstructionDesc[OpImageQuerySize].operands.push(OperandId, "'Image'");
+        InstructionDesc[OpImageQuerySize].operands.push(OperandId, "'Image'");
 
-    InstructionDesc[OpImageQueryLod].operands.push(OperandId, "'Image'");
-    InstructionDesc[OpImageQueryLod].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageQueryLod].operands.push(OperandId, "'Image'");
+        InstructionDesc[OpImageQueryLod].operands.push(OperandId, "'Coordinate'");
 
-    InstructionDesc[OpImageQueryLevels].operands.push(OperandId, "'Image'");
+        InstructionDesc[OpImageQueryLevels].operands.push(OperandId, "'Image'");
 
-    InstructionDesc[OpImageQuerySamples].operands.push(OperandId, "'Image'");
+        InstructionDesc[OpImageQuerySamples].operands.push(OperandId, "'Image'");
 
-    InstructionDesc[OpImageQueryFormat].operands.push(OperandId, "'Image'");
+        InstructionDesc[OpImageQueryFormat].operands.push(OperandId, "'Image'");
 
-    InstructionDesc[OpImageQueryOrder].operands.push(OperandId, "'Image'");
+        InstructionDesc[OpImageQueryOrder].operands.push(OperandId, "'Image'");
 
-    InstructionDesc[OpAccessChain].operands.push(OperandId, "'Base'");
-    InstructionDesc[OpAccessChain].operands.push(OperandVariableIds, "'Indexes'");
+        InstructionDesc[OpAccessChain].operands.push(OperandId, "'Base'");
+        InstructionDesc[OpAccessChain].operands.push(OperandVariableIds, "'Indexes'");
 
-    InstructionDesc[OpInBoundsAccessChain].operands.push(OperandId, "'Base'");
-    InstructionDesc[OpInBoundsAccessChain].operands.push(OperandVariableIds, "'Indexes'");
+        InstructionDesc[OpInBoundsAccessChain].operands.push(OperandId, "'Base'");
+        InstructionDesc[OpInBoundsAccessChain].operands.push(OperandVariableIds, "'Indexes'");
 
-    InstructionDesc[OpPtrAccessChain].operands.push(OperandId, "'Base'");
-    InstructionDesc[OpPtrAccessChain].operands.push(OperandId, "'Element'");
-    InstructionDesc[OpPtrAccessChain].operands.push(OperandVariableIds, "'Indexes'");
+        InstructionDesc[OpPtrAccessChain].operands.push(OperandId, "'Base'");
+        InstructionDesc[OpPtrAccessChain].operands.push(OperandId, "'Element'");
+        InstructionDesc[OpPtrAccessChain].operands.push(OperandVariableIds, "'Indexes'");
 
-    InstructionDesc[OpInBoundsPtrAccessChain].operands.push(OperandId, "'Base'");
-    InstructionDesc[OpInBoundsPtrAccessChain].operands.push(OperandId, "'Element'");
-    InstructionDesc[OpInBoundsPtrAccessChain].operands.push(OperandVariableIds, "'Indexes'");
+        InstructionDesc[OpInBoundsPtrAccessChain].operands.push(OperandId, "'Base'");
+        InstructionDesc[OpInBoundsPtrAccessChain].operands.push(OperandId, "'Element'");
+        InstructionDesc[OpInBoundsPtrAccessChain].operands.push(OperandVariableIds, "'Indexes'");
 
-    InstructionDesc[OpSNegate].operands.push(OperandId, "'Operand'");
+        InstructionDesc[OpSNegate].operands.push(OperandId, "'Operand'");
 
-    InstructionDesc[OpFNegate].operands.push(OperandId, "'Operand'");
+        InstructionDesc[OpFNegate].operands.push(OperandId, "'Operand'");
 
-    InstructionDesc[OpNot].operands.push(OperandId, "'Operand'");
+        InstructionDesc[OpNot].operands.push(OperandId, "'Operand'");
 
-    InstructionDesc[OpAny].operands.push(OperandId, "'Vector'");
+        InstructionDesc[OpAny].operands.push(OperandId, "'Vector'");
 
-    InstructionDesc[OpAll].operands.push(OperandId, "'Vector'");
+        InstructionDesc[OpAll].operands.push(OperandId, "'Vector'");
 
-    InstructionDesc[OpConvertFToU].operands.push(OperandId, "'Float Value'");
+        InstructionDesc[OpConvertFToU].operands.push(OperandId, "'Float Value'");
 
-    InstructionDesc[OpConvertFToS].operands.push(OperandId, "'Float Value'");
+        InstructionDesc[OpConvertFToS].operands.push(OperandId, "'Float Value'");
 
-    InstructionDesc[OpConvertSToF].operands.push(OperandId, "'Signed Value'");
+        InstructionDesc[OpConvertSToF].operands.push(OperandId, "'Signed Value'");
 
-    InstructionDesc[OpConvertUToF].operands.push(OperandId, "'Unsigned Value'");
+        InstructionDesc[OpConvertUToF].operands.push(OperandId, "'Unsigned Value'");
 
-    InstructionDesc[OpUConvert].operands.push(OperandId, "'Unsigned Value'");
+        InstructionDesc[OpUConvert].operands.push(OperandId, "'Unsigned Value'");
 
-    InstructionDesc[OpSConvert].operands.push(OperandId, "'Signed Value'");
+        InstructionDesc[OpSConvert].operands.push(OperandId, "'Signed Value'");
 
-    InstructionDesc[OpFConvert].operands.push(OperandId, "'Float Value'");
+        InstructionDesc[OpFConvert].operands.push(OperandId, "'Float Value'");
 
-    InstructionDesc[OpSatConvertSToU].operands.push(OperandId, "'Signed Value'");
+        InstructionDesc[OpSatConvertSToU].operands.push(OperandId, "'Signed Value'");
 
-    InstructionDesc[OpSatConvertUToS].operands.push(OperandId, "'Unsigned Value'");
+        InstructionDesc[OpSatConvertUToS].operands.push(OperandId, "'Unsigned Value'");
 
-    InstructionDesc[OpConvertPtrToU].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpConvertPtrToU].operands.push(OperandId, "'Pointer'");
 
-    InstructionDesc[OpConvertUToPtr].operands.push(OperandId, "'Integer Value'");
+        InstructionDesc[OpConvertUToPtr].operands.push(OperandId, "'Integer Value'");
 
-    InstructionDesc[OpPtrCastToGeneric].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpPtrCastToGeneric].operands.push(OperandId, "'Pointer'");
 
-    InstructionDesc[OpGenericCastToPtr].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpGenericCastToPtr].operands.push(OperandId, "'Pointer'");
 
-    InstructionDesc[OpGenericCastToPtrExplicit].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpGenericCastToPtrExplicit].operands.push(OperandStorage, "'Storage'");
+        InstructionDesc[OpGenericCastToPtrExplicit].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpGenericCastToPtrExplicit].operands.push(OperandStorage, "'Storage'");
 
-    InstructionDesc[OpGenericPtrMemSemantics].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpGenericPtrMemSemantics].operands.push(OperandId, "'Pointer'");
 
-    InstructionDesc[OpBitcast].operands.push(OperandId, "'Operand'");
+        InstructionDesc[OpBitcast].operands.push(OperandId, "'Operand'");
 
-    InstructionDesc[OpQuantizeToF16].operands.push(OperandId, "'Value'");
+        InstructionDesc[OpQuantizeToF16].operands.push(OperandId, "'Value'");
 
-    InstructionDesc[OpTranspose].operands.push(OperandId, "'Matrix'");
+        InstructionDesc[OpTranspose].operands.push(OperandId, "'Matrix'");
 
-    InstructionDesc[OpCopyLogical].operands.push(OperandId, "'Operand'");
+        InstructionDesc[OpCopyLogical].operands.push(OperandId, "'Operand'");
 
-    InstructionDesc[OpIsNan].operands.push(OperandId, "'x'");
+        InstructionDesc[OpIsNan].operands.push(OperandId, "'x'");
 
-    InstructionDesc[OpIsInf].operands.push(OperandId, "'x'");
+        InstructionDesc[OpIsInf].operands.push(OperandId, "'x'");
 
-    InstructionDesc[OpIsFinite].operands.push(OperandId, "'x'");
+        InstructionDesc[OpIsFinite].operands.push(OperandId, "'x'");
 
-    InstructionDesc[OpIsNormal].operands.push(OperandId, "'x'");
+        InstructionDesc[OpIsNormal].operands.push(OperandId, "'x'");
 
-    InstructionDesc[OpSignBitSet].operands.push(OperandId, "'x'");
+        InstructionDesc[OpSignBitSet].operands.push(OperandId, "'x'");
 
-    InstructionDesc[OpLessOrGreater].operands.push(OperandId, "'x'");
-    InstructionDesc[OpLessOrGreater].operands.push(OperandId, "'y'");
+        InstructionDesc[OpLessOrGreater].operands.push(OperandId, "'x'");
+        InstructionDesc[OpLessOrGreater].operands.push(OperandId, "'y'");
 
-    InstructionDesc[OpOrdered].operands.push(OperandId, "'x'");
-    InstructionDesc[OpOrdered].operands.push(OperandId, "'y'");
+        InstructionDesc[OpOrdered].operands.push(OperandId, "'x'");
+        InstructionDesc[OpOrdered].operands.push(OperandId, "'y'");
 
-    InstructionDesc[OpUnordered].operands.push(OperandId, "'x'");
-    InstructionDesc[OpUnordered].operands.push(OperandId, "'y'");
+        InstructionDesc[OpUnordered].operands.push(OperandId, "'x'");
+        InstructionDesc[OpUnordered].operands.push(OperandId, "'y'");
 
-    InstructionDesc[OpArrayLength].operands.push(OperandId, "'Structure'");
-    InstructionDesc[OpArrayLength].operands.push(OperandLiteralNumber, "'Array member'");
+        InstructionDesc[OpArrayLength].operands.push(OperandId, "'Structure'");
+        InstructionDesc[OpArrayLength].operands.push(OperandLiteralNumber, "'Array member'");
 
-    InstructionDesc[OpIAdd].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpIAdd].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpIAdd].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpIAdd].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpFAdd].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpFAdd].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpFAdd].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpFAdd].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpISub].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpISub].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpISub].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpISub].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpFSub].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpFSub].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpFSub].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpFSub].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpIMul].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpIMul].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpIMul].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpIMul].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpFMul].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpFMul].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpFMul].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpFMul].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpUDiv].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpUDiv].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpUDiv].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpUDiv].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpSDiv].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpSDiv].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpSDiv].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpSDiv].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpFDiv].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpFDiv].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpFDiv].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpFDiv].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpUMod].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpUMod].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpUMod].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpUMod].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpSRem].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpSRem].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpSRem].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpSRem].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpSMod].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpSMod].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpSMod].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpSMod].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpFRem].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpFRem].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpFRem].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpFRem].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpFMod].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpFMod].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpFMod].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpFMod].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpVectorTimesScalar].operands.push(OperandId, "'Vector'");
-    InstructionDesc[OpVectorTimesScalar].operands.push(OperandId, "'Scalar'");
+        InstructionDesc[OpVectorTimesScalar].operands.push(OperandId, "'Vector'");
+        InstructionDesc[OpVectorTimesScalar].operands.push(OperandId, "'Scalar'");
 
-    InstructionDesc[OpMatrixTimesScalar].operands.push(OperandId, "'Matrix'");
-    InstructionDesc[OpMatrixTimesScalar].operands.push(OperandId, "'Scalar'");
+        InstructionDesc[OpMatrixTimesScalar].operands.push(OperandId, "'Matrix'");
+        InstructionDesc[OpMatrixTimesScalar].operands.push(OperandId, "'Scalar'");
 
-    InstructionDesc[OpVectorTimesMatrix].operands.push(OperandId, "'Vector'");
-    InstructionDesc[OpVectorTimesMatrix].operands.push(OperandId, "'Matrix'");
+        InstructionDesc[OpVectorTimesMatrix].operands.push(OperandId, "'Vector'");
+        InstructionDesc[OpVectorTimesMatrix].operands.push(OperandId, "'Matrix'");
 
-    InstructionDesc[OpMatrixTimesVector].operands.push(OperandId, "'Matrix'");
-    InstructionDesc[OpMatrixTimesVector].operands.push(OperandId, "'Vector'");
+        InstructionDesc[OpMatrixTimesVector].operands.push(OperandId, "'Matrix'");
+        InstructionDesc[OpMatrixTimesVector].operands.push(OperandId, "'Vector'");
 
-    InstructionDesc[OpMatrixTimesMatrix].operands.push(OperandId, "'LeftMatrix'");
-    InstructionDesc[OpMatrixTimesMatrix].operands.push(OperandId, "'RightMatrix'");
+        InstructionDesc[OpMatrixTimesMatrix].operands.push(OperandId, "'LeftMatrix'");
+        InstructionDesc[OpMatrixTimesMatrix].operands.push(OperandId, "'RightMatrix'");
 
-    InstructionDesc[OpOuterProduct].operands.push(OperandId, "'Vector 1'");
-    InstructionDesc[OpOuterProduct].operands.push(OperandId, "'Vector 2'");
+        InstructionDesc[OpOuterProduct].operands.push(OperandId, "'Vector 1'");
+        InstructionDesc[OpOuterProduct].operands.push(OperandId, "'Vector 2'");
 
-    InstructionDesc[OpDot].operands.push(OperandId, "'Vector 1'");
-    InstructionDesc[OpDot].operands.push(OperandId, "'Vector 2'");
+        InstructionDesc[OpDot].operands.push(OperandId, "'Vector 1'");
+        InstructionDesc[OpDot].operands.push(OperandId, "'Vector 2'");
 
-    InstructionDesc[OpIAddCarry].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpIAddCarry].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpIAddCarry].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpIAddCarry].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpISubBorrow].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpISubBorrow].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpISubBorrow].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpISubBorrow].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpUMulExtended].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpUMulExtended].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpUMulExtended].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpUMulExtended].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpSMulExtended].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpSMulExtended].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpSMulExtended].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpSMulExtended].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpShiftRightLogical].operands.push(OperandId, "'Base'");
-    InstructionDesc[OpShiftRightLogical].operands.push(OperandId, "'Shift'");
+        InstructionDesc[OpShiftRightLogical].operands.push(OperandId, "'Base'");
+        InstructionDesc[OpShiftRightLogical].operands.push(OperandId, "'Shift'");
 
-    InstructionDesc[OpShiftRightArithmetic].operands.push(OperandId, "'Base'");
-    InstructionDesc[OpShiftRightArithmetic].operands.push(OperandId, "'Shift'");
+        InstructionDesc[OpShiftRightArithmetic].operands.push(OperandId, "'Base'");
+        InstructionDesc[OpShiftRightArithmetic].operands.push(OperandId, "'Shift'");
 
-    InstructionDesc[OpShiftLeftLogical].operands.push(OperandId, "'Base'");
-    InstructionDesc[OpShiftLeftLogical].operands.push(OperandId, "'Shift'");
+        InstructionDesc[OpShiftLeftLogical].operands.push(OperandId, "'Base'");
+        InstructionDesc[OpShiftLeftLogical].operands.push(OperandId, "'Shift'");
 
-    InstructionDesc[OpLogicalOr].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpLogicalOr].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpLogicalOr].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpLogicalOr].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpLogicalAnd].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpLogicalAnd].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpLogicalAnd].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpLogicalAnd].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpLogicalEqual].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpLogicalEqual].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpLogicalEqual].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpLogicalEqual].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpLogicalNotEqual].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpLogicalNotEqual].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpLogicalNotEqual].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpLogicalNotEqual].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpLogicalNot].operands.push(OperandId, "'Operand'");
+        InstructionDesc[OpLogicalNot].operands.push(OperandId, "'Operand'");
 
-    InstructionDesc[OpBitwiseOr].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpBitwiseOr].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpBitwiseOr].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpBitwiseOr].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpBitwiseXor].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpBitwiseXor].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpBitwiseXor].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpBitwiseXor].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpBitwiseAnd].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpBitwiseAnd].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpBitwiseAnd].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpBitwiseAnd].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpBitFieldInsert].operands.push(OperandId, "'Base'");
-    InstructionDesc[OpBitFieldInsert].operands.push(OperandId, "'Insert'");
-    InstructionDesc[OpBitFieldInsert].operands.push(OperandId, "'Offset'");
-    InstructionDesc[OpBitFieldInsert].operands.push(OperandId, "'Count'");
+        InstructionDesc[OpBitFieldInsert].operands.push(OperandId, "'Base'");
+        InstructionDesc[OpBitFieldInsert].operands.push(OperandId, "'Insert'");
+        InstructionDesc[OpBitFieldInsert].operands.push(OperandId, "'Offset'");
+        InstructionDesc[OpBitFieldInsert].operands.push(OperandId, "'Count'");
 
-    InstructionDesc[OpBitFieldSExtract].operands.push(OperandId, "'Base'");
-    InstructionDesc[OpBitFieldSExtract].operands.push(OperandId, "'Offset'");
-    InstructionDesc[OpBitFieldSExtract].operands.push(OperandId, "'Count'");
-    
-    InstructionDesc[OpBitFieldUExtract].operands.push(OperandId, "'Base'");
-    InstructionDesc[OpBitFieldUExtract].operands.push(OperandId, "'Offset'");
-    InstructionDesc[OpBitFieldUExtract].operands.push(OperandId, "'Count'");
-    
-    InstructionDesc[OpBitReverse].operands.push(OperandId, "'Base'");
+        InstructionDesc[OpBitFieldSExtract].operands.push(OperandId, "'Base'");
+        InstructionDesc[OpBitFieldSExtract].operands.push(OperandId, "'Offset'");
+        InstructionDesc[OpBitFieldSExtract].operands.push(OperandId, "'Count'");
 
-    InstructionDesc[OpBitCount].operands.push(OperandId, "'Base'");
+        InstructionDesc[OpBitFieldUExtract].operands.push(OperandId, "'Base'");
+        InstructionDesc[OpBitFieldUExtract].operands.push(OperandId, "'Offset'");
+        InstructionDesc[OpBitFieldUExtract].operands.push(OperandId, "'Count'");
 
-    InstructionDesc[OpSelect].operands.push(OperandId, "'Condition'");
-    InstructionDesc[OpSelect].operands.push(OperandId, "'Object 1'");
-    InstructionDesc[OpSelect].operands.push(OperandId, "'Object 2'");
+        InstructionDesc[OpBitReverse].operands.push(OperandId, "'Base'");
 
-    InstructionDesc[OpIEqual].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpIEqual].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpBitCount].operands.push(OperandId, "'Base'");
 
-    InstructionDesc[OpFOrdEqual].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpFOrdEqual].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpSelect].operands.push(OperandId, "'Condition'");
+        InstructionDesc[OpSelect].operands.push(OperandId, "'Object 1'");
+        InstructionDesc[OpSelect].operands.push(OperandId, "'Object 2'");
 
-    InstructionDesc[OpFUnordEqual].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpFUnordEqual].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpIEqual].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpIEqual].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpINotEqual].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpINotEqual].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpFOrdEqual].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpFOrdEqual].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpFOrdNotEqual].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpFOrdNotEqual].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpFUnordEqual].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpFUnordEqual].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpFUnordNotEqual].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpFUnordNotEqual].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpINotEqual].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpINotEqual].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpULessThan].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpULessThan].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpFOrdNotEqual].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpFOrdNotEqual].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpSLessThan].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpSLessThan].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpFUnordNotEqual].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpFUnordNotEqual].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpFOrdLessThan].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpFOrdLessThan].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpULessThan].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpULessThan].operands.push(OperandId, "'Operand 2'");
+
+        InstructionDesc[OpSLessThan].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpSLessThan].operands.push(OperandId, "'Operand 2'");
+
+        InstructionDesc[OpFOrdLessThan].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpFOrdLessThan].operands.push(OperandId, "'Operand 2'");
+
+        InstructionDesc[OpFUnordLessThan].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpFUnordLessThan].operands.push(OperandId, "'Operand 2'");
+
+        InstructionDesc[OpUGreaterThan].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpUGreaterThan].operands.push(OperandId, "'Operand 2'");
+
+        InstructionDesc[OpSGreaterThan].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpSGreaterThan].operands.push(OperandId, "'Operand 2'");
+
+        InstructionDesc[OpFOrdGreaterThan].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpFOrdGreaterThan].operands.push(OperandId, "'Operand 2'");
+
+        InstructionDesc[OpFUnordGreaterThan].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpFUnordGreaterThan].operands.push(OperandId, "'Operand 2'");
+
+        InstructionDesc[OpULessThanEqual].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpULessThanEqual].operands.push(OperandId, "'Operand 2'");
+
+        InstructionDesc[OpSLessThanEqual].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpSLessThanEqual].operands.push(OperandId, "'Operand 2'");
+
+        InstructionDesc[OpFOrdLessThanEqual].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpFOrdLessThanEqual].operands.push(OperandId, "'Operand 2'");
+
+        InstructionDesc[OpFUnordLessThanEqual].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpFUnordLessThanEqual].operands.push(OperandId, "'Operand 2'");
+
+        InstructionDesc[OpUGreaterThanEqual].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpUGreaterThanEqual].operands.push(OperandId, "'Operand 2'");
+
+        InstructionDesc[OpSGreaterThanEqual].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpSGreaterThanEqual].operands.push(OperandId, "'Operand 2'");
+
+        InstructionDesc[OpFOrdGreaterThanEqual].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpFOrdGreaterThanEqual].operands.push(OperandId, "'Operand 2'");
+
+        InstructionDesc[OpFUnordGreaterThanEqual].operands.push(OperandId, "'Operand 1'");
+        InstructionDesc[OpFUnordGreaterThanEqual].operands.push(OperandId, "'Operand 2'");
+
+        InstructionDesc[OpDPdx].operands.push(OperandId, "'P'");
+
+        InstructionDesc[OpDPdy].operands.push(OperandId, "'P'");
+
+        InstructionDesc[OpFwidth].operands.push(OperandId, "'P'");
+
+        InstructionDesc[OpDPdxFine].operands.push(OperandId, "'P'");
+
+        InstructionDesc[OpDPdyFine].operands.push(OperandId, "'P'");
+
+        InstructionDesc[OpFwidthFine].operands.push(OperandId, "'P'");
+
+        InstructionDesc[OpDPdxCoarse].operands.push(OperandId, "'P'");
+
+        InstructionDesc[OpDPdyCoarse].operands.push(OperandId, "'P'");
+
+        InstructionDesc[OpFwidthCoarse].operands.push(OperandId, "'P'");
+
+        InstructionDesc[OpEmitStreamVertex].operands.push(OperandId, "'Stream'");
+
+        InstructionDesc[OpEndStreamPrimitive].operands.push(OperandId, "'Stream'");
+
+        InstructionDesc[OpControlBarrier].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpControlBarrier].operands.push(OperandScope, "'Memory'");
+        InstructionDesc[OpControlBarrier].operands.push(OperandMemorySemantics, "'Semantics'");
+
+        InstructionDesc[OpMemoryBarrier].operands.push(OperandScope, "'Memory'");
+        InstructionDesc[OpMemoryBarrier].operands.push(OperandMemorySemantics, "'Semantics'");
+
+        InstructionDesc[OpImageTexelPointer].operands.push(OperandId, "'Image'");
+        InstructionDesc[OpImageTexelPointer].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageTexelPointer].operands.push(OperandId, "'Sample'");
+
+        InstructionDesc[OpAtomicLoad].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpAtomicLoad].operands.push(OperandScope, "'Scope'");
+        InstructionDesc[OpAtomicLoad].operands.push(OperandMemorySemantics, "'Semantics'");
+
+        InstructionDesc[OpAtomicStore].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpAtomicStore].operands.push(OperandScope, "'Scope'");
+        InstructionDesc[OpAtomicStore].operands.push(OperandMemorySemantics, "'Semantics'");
+        InstructionDesc[OpAtomicStore].operands.push(OperandId, "'Value'");
+
+        InstructionDesc[OpAtomicExchange].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpAtomicExchange].operands.push(OperandScope, "'Scope'");
+        InstructionDesc[OpAtomicExchange].operands.push(OperandMemorySemantics, "'Semantics'");
+        InstructionDesc[OpAtomicExchange].operands.push(OperandId, "'Value'");
+
+        InstructionDesc[OpAtomicCompareExchange].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpAtomicCompareExchange].operands.push(OperandScope, "'Scope'");
+        InstructionDesc[OpAtomicCompareExchange].operands.push(OperandMemorySemantics, "'Equal'");
+        InstructionDesc[OpAtomicCompareExchange].operands.push(OperandMemorySemantics, "'Unequal'");
+        InstructionDesc[OpAtomicCompareExchange].operands.push(OperandId, "'Value'");
+        InstructionDesc[OpAtomicCompareExchange].operands.push(OperandId, "'Comparator'");
+
+        InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandScope, "'Scope'");
+        InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandMemorySemantics, "'Equal'");
+        InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandMemorySemantics, "'Unequal'");
+        InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandId, "'Value'");
+        InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandId, "'Comparator'");
+
+        InstructionDesc[OpAtomicIIncrement].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpAtomicIIncrement].operands.push(OperandScope, "'Scope'");
+        InstructionDesc[OpAtomicIIncrement].operands.push(OperandMemorySemantics, "'Semantics'");
+
+        InstructionDesc[OpAtomicIDecrement].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpAtomicIDecrement].operands.push(OperandScope, "'Scope'");
+        InstructionDesc[OpAtomicIDecrement].operands.push(OperandMemorySemantics, "'Semantics'");
+
+        InstructionDesc[OpAtomicIAdd].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpAtomicIAdd].operands.push(OperandScope, "'Scope'");
+        InstructionDesc[OpAtomicIAdd].operands.push(OperandMemorySemantics, "'Semantics'");
+        InstructionDesc[OpAtomicIAdd].operands.push(OperandId, "'Value'");
+
+        InstructionDesc[OpAtomicFAddEXT].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpAtomicFAddEXT].operands.push(OperandScope, "'Scope'");
+        InstructionDesc[OpAtomicFAddEXT].operands.push(OperandMemorySemantics, "'Semantics'");
+        InstructionDesc[OpAtomicFAddEXT].operands.push(OperandId, "'Value'");
+
+        InstructionDesc[OpAtomicISub].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpAtomicISub].operands.push(OperandScope, "'Scope'");
+        InstructionDesc[OpAtomicISub].operands.push(OperandMemorySemantics, "'Semantics'");
+        InstructionDesc[OpAtomicISub].operands.push(OperandId, "'Value'");
+
+        InstructionDesc[OpAtomicUMin].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpAtomicUMin].operands.push(OperandScope, "'Scope'");
+        InstructionDesc[OpAtomicUMin].operands.push(OperandMemorySemantics, "'Semantics'");
+        InstructionDesc[OpAtomicUMin].operands.push(OperandId, "'Value'");
+
+        InstructionDesc[OpAtomicUMax].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpAtomicUMax].operands.push(OperandScope, "'Scope'");
+        InstructionDesc[OpAtomicUMax].operands.push(OperandMemorySemantics, "'Semantics'");
+        InstructionDesc[OpAtomicUMax].operands.push(OperandId, "'Value'");
+
+        InstructionDesc[OpAtomicSMin].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpAtomicSMin].operands.push(OperandScope, "'Scope'");
+        InstructionDesc[OpAtomicSMin].operands.push(OperandMemorySemantics, "'Semantics'");
+        InstructionDesc[OpAtomicSMin].operands.push(OperandId, "'Value'");
+
+        InstructionDesc[OpAtomicSMax].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpAtomicSMax].operands.push(OperandScope, "'Scope'");
+        InstructionDesc[OpAtomicSMax].operands.push(OperandMemorySemantics, "'Semantics'");
+        InstructionDesc[OpAtomicSMax].operands.push(OperandId, "'Value'");
+
+        InstructionDesc[OpAtomicFMinEXT].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpAtomicFMinEXT].operands.push(OperandScope, "'Scope'");
+        InstructionDesc[OpAtomicFMinEXT].operands.push(OperandMemorySemantics, "'Semantics'");
+        InstructionDesc[OpAtomicFMinEXT].operands.push(OperandId, "'Value'");
+
+        InstructionDesc[OpAtomicFMaxEXT].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpAtomicFMaxEXT].operands.push(OperandScope, "'Scope'");
+        InstructionDesc[OpAtomicFMaxEXT].operands.push(OperandMemorySemantics, "'Semantics'");
+        InstructionDesc[OpAtomicFMaxEXT].operands.push(OperandId, "'Value'");
+
+        InstructionDesc[OpAtomicAnd].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpAtomicAnd].operands.push(OperandScope, "'Scope'");
+        InstructionDesc[OpAtomicAnd].operands.push(OperandMemorySemantics, "'Semantics'");
+        InstructionDesc[OpAtomicAnd].operands.push(OperandId, "'Value'");
+
+        InstructionDesc[OpAtomicOr].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpAtomicOr].operands.push(OperandScope, "'Scope'");
+        InstructionDesc[OpAtomicOr].operands.push(OperandMemorySemantics, "'Semantics'");
+        InstructionDesc[OpAtomicOr].operands.push(OperandId, "'Value'");
+
+        InstructionDesc[OpAtomicXor].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpAtomicXor].operands.push(OperandScope, "'Scope'");
+        InstructionDesc[OpAtomicXor].operands.push(OperandMemorySemantics, "'Semantics'");
+        InstructionDesc[OpAtomicXor].operands.push(OperandId, "'Value'");
+
+        InstructionDesc[OpAtomicFlagTestAndSet].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpAtomicFlagTestAndSet].operands.push(OperandScope, "'Scope'");
+        InstructionDesc[OpAtomicFlagTestAndSet].operands.push(OperandMemorySemantics, "'Semantics'");
+
+        InstructionDesc[OpAtomicFlagClear].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpAtomicFlagClear].operands.push(OperandScope, "'Scope'");
+        InstructionDesc[OpAtomicFlagClear].operands.push(OperandMemorySemantics, "'Semantics'");
 
-    InstructionDesc[OpFUnordLessThan].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpFUnordLessThan].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpLoopMerge].operands.push(OperandId, "'Merge Block'");
+        InstructionDesc[OpLoopMerge].operands.push(OperandId, "'Continue Target'");
+        InstructionDesc[OpLoopMerge].operands.push(OperandLoop, "");
+        InstructionDesc[OpLoopMerge].operands.push(OperandOptionalLiteral, "");
 
-    InstructionDesc[OpUGreaterThan].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpUGreaterThan].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpSelectionMerge].operands.push(OperandId, "'Merge Block'");
+        InstructionDesc[OpSelectionMerge].operands.push(OperandSelect, "");
 
-    InstructionDesc[OpSGreaterThan].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpSGreaterThan].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpBranch].operands.push(OperandId, "'Target Label'");
 
-    InstructionDesc[OpFOrdGreaterThan].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpFOrdGreaterThan].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpBranchConditional].operands.push(OperandId, "'Condition'");
+        InstructionDesc[OpBranchConditional].operands.push(OperandId, "'True Label'");
+        InstructionDesc[OpBranchConditional].operands.push(OperandId, "'False Label'");
+        InstructionDesc[OpBranchConditional].operands.push(OperandVariableLiterals, "'Branch weights'");
 
-    InstructionDesc[OpFUnordGreaterThan].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpFUnordGreaterThan].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpSwitch].operands.push(OperandId, "'Selector'");
+        InstructionDesc[OpSwitch].operands.push(OperandId, "'Default'");
+        InstructionDesc[OpSwitch].operands.push(OperandVariableLiteralId, "'Target'");
 
-    InstructionDesc[OpULessThanEqual].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpULessThanEqual].operands.push(OperandId, "'Operand 2'");
 
-    InstructionDesc[OpSLessThanEqual].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpSLessThanEqual].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpReturnValue].operands.push(OperandId, "'Value'");
 
-    InstructionDesc[OpFOrdLessThanEqual].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpFOrdLessThanEqual].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpLifetimeStart].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpLifetimeStart].operands.push(OperandLiteralNumber, "'Size'");
 
-    InstructionDesc[OpFUnordLessThanEqual].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpFUnordLessThanEqual].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpLifetimeStop].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpLifetimeStop].operands.push(OperandLiteralNumber, "'Size'");
 
-    InstructionDesc[OpUGreaterThanEqual].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpUGreaterThanEqual].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpGroupAsyncCopy].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Destination'");
+        InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Source'");
+        InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Num Elements'");
+        InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Stride'");
+        InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Event'");
 
-    InstructionDesc[OpSGreaterThanEqual].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpSGreaterThanEqual].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpGroupWaitEvents].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupWaitEvents].operands.push(OperandId, "'Num Events'");
+        InstructionDesc[OpGroupWaitEvents].operands.push(OperandId, "'Events List'");
 
-    InstructionDesc[OpFOrdGreaterThanEqual].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpFOrdGreaterThanEqual].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpGroupAll].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupAll].operands.push(OperandId, "'Predicate'");
 
-    InstructionDesc[OpFUnordGreaterThanEqual].operands.push(OperandId, "'Operand 1'");
-    InstructionDesc[OpFUnordGreaterThanEqual].operands.push(OperandId, "'Operand 2'");
+        InstructionDesc[OpGroupAny].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupAny].operands.push(OperandId, "'Predicate'");
 
-    InstructionDesc[OpDPdx].operands.push(OperandId, "'P'");
+        InstructionDesc[OpGroupBroadcast].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupBroadcast].operands.push(OperandId, "'Value'");
+        InstructionDesc[OpGroupBroadcast].operands.push(OperandId, "'LocalId'");
 
-    InstructionDesc[OpDPdy].operands.push(OperandId, "'P'");
+        InstructionDesc[OpGroupIAdd].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupIAdd].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupIAdd].operands.push(OperandId, "'X'");
 
-    InstructionDesc[OpFwidth].operands.push(OperandId, "'P'");
+        InstructionDesc[OpGroupFAdd].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupFAdd].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupFAdd].operands.push(OperandId, "'X'");
 
-    InstructionDesc[OpDPdxFine].operands.push(OperandId, "'P'");
+        InstructionDesc[OpGroupUMin].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupUMin].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupUMin].operands.push(OperandId, "'X'");
 
-    InstructionDesc[OpDPdyFine].operands.push(OperandId, "'P'");
+        InstructionDesc[OpGroupSMin].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupSMin].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupSMin].operands.push(OperandId, "X");
 
-    InstructionDesc[OpFwidthFine].operands.push(OperandId, "'P'");
+        InstructionDesc[OpGroupFMin].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupFMin].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupFMin].operands.push(OperandId, "X");
 
-    InstructionDesc[OpDPdxCoarse].operands.push(OperandId, "'P'");
+        InstructionDesc[OpGroupUMax].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupUMax].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupUMax].operands.push(OperandId, "X");
 
-    InstructionDesc[OpDPdyCoarse].operands.push(OperandId, "'P'");
+        InstructionDesc[OpGroupSMax].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupSMax].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupSMax].operands.push(OperandId, "X");
 
-    InstructionDesc[OpFwidthCoarse].operands.push(OperandId, "'P'");
+        InstructionDesc[OpGroupFMax].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupFMax].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupFMax].operands.push(OperandId, "X");
 
-    InstructionDesc[OpEmitStreamVertex].operands.push(OperandId, "'Stream'");
+        InstructionDesc[OpReadPipe].operands.push(OperandId, "'Pipe'");
+        InstructionDesc[OpReadPipe].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpReadPipe].operands.push(OperandId, "'Packet Size'");
+        InstructionDesc[OpReadPipe].operands.push(OperandId, "'Packet Alignment'");
 
-    InstructionDesc[OpEndStreamPrimitive].operands.push(OperandId, "'Stream'");
+        InstructionDesc[OpWritePipe].operands.push(OperandId, "'Pipe'");
+        InstructionDesc[OpWritePipe].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpWritePipe].operands.push(OperandId, "'Packet Size'");
+        InstructionDesc[OpWritePipe].operands.push(OperandId, "'Packet Alignment'");
 
-    InstructionDesc[OpControlBarrier].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpControlBarrier].operands.push(OperandScope, "'Memory'");
-    InstructionDesc[OpControlBarrier].operands.push(OperandMemorySemantics, "'Semantics'");
+        InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Pipe'");
+        InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Reserve Id'");
+        InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Index'");
+        InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Packet Size'");
+        InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Packet Alignment'");
 
-    InstructionDesc[OpMemoryBarrier].operands.push(OperandScope, "'Memory'");
-    InstructionDesc[OpMemoryBarrier].operands.push(OperandMemorySemantics, "'Semantics'");
+        InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Pipe'");
+        InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Reserve Id'");
+        InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Index'");
+        InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Packet Size'");
+        InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Packet Alignment'");
 
-    InstructionDesc[OpImageTexelPointer].operands.push(OperandId, "'Image'");
-    InstructionDesc[OpImageTexelPointer].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageTexelPointer].operands.push(OperandId, "'Sample'");
+        InstructionDesc[OpReserveReadPipePackets].operands.push(OperandId, "'Pipe'");
+        InstructionDesc[OpReserveReadPipePackets].operands.push(OperandId, "'Num Packets'");
+        InstructionDesc[OpReserveReadPipePackets].operands.push(OperandId, "'Packet Size'");
+        InstructionDesc[OpReserveReadPipePackets].operands.push(OperandId, "'Packet Alignment'");
 
-    InstructionDesc[OpAtomicLoad].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpAtomicLoad].operands.push(OperandScope, "'Scope'");
-    InstructionDesc[OpAtomicLoad].operands.push(OperandMemorySemantics, "'Semantics'");
+        InstructionDesc[OpReserveWritePipePackets].operands.push(OperandId, "'Pipe'");
+        InstructionDesc[OpReserveWritePipePackets].operands.push(OperandId, "'Num Packets'");
+        InstructionDesc[OpReserveWritePipePackets].operands.push(OperandId, "'Packet Size'");
+        InstructionDesc[OpReserveWritePipePackets].operands.push(OperandId, "'Packet Alignment'");
 
-    InstructionDesc[OpAtomicStore].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpAtomicStore].operands.push(OperandScope, "'Scope'");
-    InstructionDesc[OpAtomicStore].operands.push(OperandMemorySemantics, "'Semantics'");
-    InstructionDesc[OpAtomicStore].operands.push(OperandId, "'Value'");
+        InstructionDesc[OpCommitReadPipe].operands.push(OperandId, "'Pipe'");
+        InstructionDesc[OpCommitReadPipe].operands.push(OperandId, "'Reserve Id'");
+        InstructionDesc[OpCommitReadPipe].operands.push(OperandId, "'Packet Size'");
+        InstructionDesc[OpCommitReadPipe].operands.push(OperandId, "'Packet Alignment'");
 
-    InstructionDesc[OpAtomicExchange].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpAtomicExchange].operands.push(OperandScope, "'Scope'");
-    InstructionDesc[OpAtomicExchange].operands.push(OperandMemorySemantics, "'Semantics'");
-    InstructionDesc[OpAtomicExchange].operands.push(OperandId, "'Value'");
+        InstructionDesc[OpCommitWritePipe].operands.push(OperandId, "'Pipe'");
+        InstructionDesc[OpCommitWritePipe].operands.push(OperandId, "'Reserve Id'");
+        InstructionDesc[OpCommitWritePipe].operands.push(OperandId, "'Packet Size'");
+        InstructionDesc[OpCommitWritePipe].operands.push(OperandId, "'Packet Alignment'");
 
-    InstructionDesc[OpAtomicCompareExchange].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpAtomicCompareExchange].operands.push(OperandScope, "'Scope'");
-    InstructionDesc[OpAtomicCompareExchange].operands.push(OperandMemorySemantics, "'Equal'");
-    InstructionDesc[OpAtomicCompareExchange].operands.push(OperandMemorySemantics, "'Unequal'");
-    InstructionDesc[OpAtomicCompareExchange].operands.push(OperandId, "'Value'");
-    InstructionDesc[OpAtomicCompareExchange].operands.push(OperandId, "'Comparator'");
+        InstructionDesc[OpIsValidReserveId].operands.push(OperandId, "'Reserve Id'");
 
-    InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandScope, "'Scope'");
-    InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandMemorySemantics, "'Equal'");
-    InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandMemorySemantics, "'Unequal'");
-    InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandId, "'Value'");
-    InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandId, "'Comparator'");
+        InstructionDesc[OpGetNumPipePackets].operands.push(OperandId, "'Pipe'");
+        InstructionDesc[OpGetNumPipePackets].operands.push(OperandId, "'Packet Size'");
+        InstructionDesc[OpGetNumPipePackets].operands.push(OperandId, "'Packet Alignment'");
 
-    InstructionDesc[OpAtomicIIncrement].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpAtomicIIncrement].operands.push(OperandScope, "'Scope'");
-    InstructionDesc[OpAtomicIIncrement].operands.push(OperandMemorySemantics, "'Semantics'");
+        InstructionDesc[OpGetMaxPipePackets].operands.push(OperandId, "'Pipe'");
+        InstructionDesc[OpGetMaxPipePackets].operands.push(OperandId, "'Packet Size'");
+        InstructionDesc[OpGetMaxPipePackets].operands.push(OperandId, "'Packet Alignment'");
 
-    InstructionDesc[OpAtomicIDecrement].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpAtomicIDecrement].operands.push(OperandScope, "'Scope'");
-    InstructionDesc[OpAtomicIDecrement].operands.push(OperandMemorySemantics, "'Semantics'");
+        InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandId, "'Pipe'");
+        InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandId, "'Num Packets'");
+        InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandId, "'Packet Size'");
+        InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandId, "'Packet Alignment'");
 
-    InstructionDesc[OpAtomicIAdd].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpAtomicIAdd].operands.push(OperandScope, "'Scope'");
-    InstructionDesc[OpAtomicIAdd].operands.push(OperandMemorySemantics, "'Semantics'");
-    InstructionDesc[OpAtomicIAdd].operands.push(OperandId, "'Value'");
+        InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandId, "'Pipe'");
+        InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandId, "'Num Packets'");
+        InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandId, "'Packet Size'");
+        InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandId, "'Packet Alignment'");
 
-    InstructionDesc[OpAtomicFAddEXT].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpAtomicFAddEXT].operands.push(OperandScope, "'Scope'");
-    InstructionDesc[OpAtomicFAddEXT].operands.push(OperandMemorySemantics, "'Semantics'");
-    InstructionDesc[OpAtomicFAddEXT].operands.push(OperandId, "'Value'");
+        InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandId, "'Pipe'");
+        InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandId, "'Reserve Id'");
+        InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandId, "'Packet Size'");
+        InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandId, "'Packet Alignment'");
 
-    InstructionDesc[OpAtomicISub].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpAtomicISub].operands.push(OperandScope, "'Scope'");
-    InstructionDesc[OpAtomicISub].operands.push(OperandMemorySemantics, "'Semantics'");
-    InstructionDesc[OpAtomicISub].operands.push(OperandId, "'Value'");
+        InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandId, "'Pipe'");
+        InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandId, "'Reserve Id'");
+        InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandId, "'Packet Size'");
+        InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandId, "'Packet Alignment'");
 
-    InstructionDesc[OpAtomicUMin].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpAtomicUMin].operands.push(OperandScope, "'Scope'");
-    InstructionDesc[OpAtomicUMin].operands.push(OperandMemorySemantics, "'Semantics'");
-    InstructionDesc[OpAtomicUMin].operands.push(OperandId, "'Value'");
+        InstructionDesc[OpBuildNDRange].operands.push(OperandId, "'GlobalWorkSize'");
+        InstructionDesc[OpBuildNDRange].operands.push(OperandId, "'LocalWorkSize'");
+        InstructionDesc[OpBuildNDRange].operands.push(OperandId, "'GlobalWorkOffset'");
 
-    InstructionDesc[OpAtomicUMax].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpAtomicUMax].operands.push(OperandScope, "'Scope'");
-    InstructionDesc[OpAtomicUMax].operands.push(OperandMemorySemantics, "'Semantics'");
-    InstructionDesc[OpAtomicUMax].operands.push(OperandId, "'Value'");
+        InstructionDesc[OpCaptureEventProfilingInfo].operands.push(OperandId, "'Event'");
+        InstructionDesc[OpCaptureEventProfilingInfo].operands.push(OperandId, "'Profiling Info'");
+        InstructionDesc[OpCaptureEventProfilingInfo].operands.push(OperandId, "'Value'");
 
-    InstructionDesc[OpAtomicSMin].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpAtomicSMin].operands.push(OperandScope, "'Scope'");
-    InstructionDesc[OpAtomicSMin].operands.push(OperandMemorySemantics, "'Semantics'");
-    InstructionDesc[OpAtomicSMin].operands.push(OperandId, "'Value'");
+        InstructionDesc[OpSetUserEventStatus].operands.push(OperandId, "'Event'");
+        InstructionDesc[OpSetUserEventStatus].operands.push(OperandId, "'Status'");
 
-    InstructionDesc[OpAtomicSMax].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpAtomicSMax].operands.push(OperandScope, "'Scope'");
-    InstructionDesc[OpAtomicSMax].operands.push(OperandMemorySemantics, "'Semantics'");
-    InstructionDesc[OpAtomicSMax].operands.push(OperandId, "'Value'");
+        InstructionDesc[OpIsValidEvent].operands.push(OperandId, "'Event'");
 
-    InstructionDesc[OpAtomicFMinEXT].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpAtomicFMinEXT].operands.push(OperandScope, "'Scope'");
-    InstructionDesc[OpAtomicFMinEXT].operands.push(OperandMemorySemantics, "'Semantics'");
-    InstructionDesc[OpAtomicFMinEXT].operands.push(OperandId, "'Value'");
+        InstructionDesc[OpRetainEvent].operands.push(OperandId, "'Event'");
 
-    InstructionDesc[OpAtomicFMaxEXT].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpAtomicFMaxEXT].operands.push(OperandScope, "'Scope'");
-    InstructionDesc[OpAtomicFMaxEXT].operands.push(OperandMemorySemantics, "'Semantics'");
-    InstructionDesc[OpAtomicFMaxEXT].operands.push(OperandId, "'Value'");
+        InstructionDesc[OpReleaseEvent].operands.push(OperandId, "'Event'");
 
-    InstructionDesc[OpAtomicAnd].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpAtomicAnd].operands.push(OperandScope, "'Scope'");
-    InstructionDesc[OpAtomicAnd].operands.push(OperandMemorySemantics, "'Semantics'");
-    InstructionDesc[OpAtomicAnd].operands.push(OperandId, "'Value'");
+        InstructionDesc[OpGetKernelWorkGroupSize].operands.push(OperandId, "'Invoke'");
+        InstructionDesc[OpGetKernelWorkGroupSize].operands.push(OperandId, "'Param'");
+        InstructionDesc[OpGetKernelWorkGroupSize].operands.push(OperandId, "'Param Size'");
+        InstructionDesc[OpGetKernelWorkGroupSize].operands.push(OperandId, "'Param Align'");
 
-    InstructionDesc[OpAtomicOr].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpAtomicOr].operands.push(OperandScope, "'Scope'");
-    InstructionDesc[OpAtomicOr].operands.push(OperandMemorySemantics, "'Semantics'");
-    InstructionDesc[OpAtomicOr].operands.push(OperandId, "'Value'");
+        InstructionDesc[OpGetKernelPreferredWorkGroupSizeMultiple].operands.push(OperandId, "'Invoke'");
+        InstructionDesc[OpGetKernelPreferredWorkGroupSizeMultiple].operands.push(OperandId, "'Param'");
+        InstructionDesc[OpGetKernelPreferredWorkGroupSizeMultiple].operands.push(OperandId, "'Param Size'");
+        InstructionDesc[OpGetKernelPreferredWorkGroupSizeMultiple].operands.push(OperandId, "'Param Align'");
 
-    InstructionDesc[OpAtomicXor].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpAtomicXor].operands.push(OperandScope, "'Scope'");
-    InstructionDesc[OpAtomicXor].operands.push(OperandMemorySemantics, "'Semantics'");
-    InstructionDesc[OpAtomicXor].operands.push(OperandId, "'Value'");
+        InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'ND Range'");
+        InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'Invoke'");
+        InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'Param'");
+        InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'Param Size'");
+        InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'Param Align'");
 
-    InstructionDesc[OpAtomicFlagTestAndSet].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpAtomicFlagTestAndSet].operands.push(OperandScope, "'Scope'");
-    InstructionDesc[OpAtomicFlagTestAndSet].operands.push(OperandMemorySemantics, "'Semantics'");
+        InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'ND Range'");
+        InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'Invoke'");
+        InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'Param'");
+        InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'Param Size'");
+        InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'Param Align'");
 
-    InstructionDesc[OpAtomicFlagClear].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpAtomicFlagClear].operands.push(OperandScope, "'Scope'");
-    InstructionDesc[OpAtomicFlagClear].operands.push(OperandMemorySemantics, "'Semantics'");
+        InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Queue'");
+        InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Flags'");
+        InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'ND Range'");
+        InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Num Events'");
+        InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Wait Events'");
+        InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Ret Event'");
+        InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Invoke'");
+        InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Param'");
+        InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Param Size'");
+        InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Param Align'");
+        InstructionDesc[OpEnqueueKernel].operands.push(OperandVariableIds, "'Local Size'");
 
-    InstructionDesc[OpLoopMerge].operands.push(OperandId, "'Merge Block'");
-    InstructionDesc[OpLoopMerge].operands.push(OperandId, "'Continue Target'");
-    InstructionDesc[OpLoopMerge].operands.push(OperandLoop, "");
-    InstructionDesc[OpLoopMerge].operands.push(OperandOptionalLiteral, "");
+        InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Queue'");
+        InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Num Events'");
+        InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Wait Events'");
+        InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Ret Event'");
 
-    InstructionDesc[OpSelectionMerge].operands.push(OperandId, "'Merge Block'");
-    InstructionDesc[OpSelectionMerge].operands.push(OperandSelect, "");
+        InstructionDesc[OpGroupNonUniformElect].operands.push(OperandScope, "'Execution'");
 
-    InstructionDesc[OpBranch].operands.push(OperandId, "'Target Label'");
+        InstructionDesc[OpGroupNonUniformAll].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformAll].operands.push(OperandId, "X");
 
-    InstructionDesc[OpBranchConditional].operands.push(OperandId, "'Condition'");
-    InstructionDesc[OpBranchConditional].operands.push(OperandId, "'True Label'");
-    InstructionDesc[OpBranchConditional].operands.push(OperandId, "'False Label'");
-    InstructionDesc[OpBranchConditional].operands.push(OperandVariableLiterals, "'Branch weights'");
+        InstructionDesc[OpGroupNonUniformAny].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformAny].operands.push(OperandId, "X");
 
-    InstructionDesc[OpSwitch].operands.push(OperandId, "'Selector'");
-    InstructionDesc[OpSwitch].operands.push(OperandId, "'Default'");
-    InstructionDesc[OpSwitch].operands.push(OperandVariableLiteralId, "'Target'");
+        InstructionDesc[OpGroupNonUniformAllEqual].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformAllEqual].operands.push(OperandId, "X");
 
+        InstructionDesc[OpGroupNonUniformBroadcast].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformBroadcast].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformBroadcast].operands.push(OperandId, "ID");
 
-    InstructionDesc[OpReturnValue].operands.push(OperandId, "'Value'");
+        InstructionDesc[OpGroupNonUniformBroadcastFirst].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformBroadcastFirst].operands.push(OperandId, "X");
 
-    InstructionDesc[OpLifetimeStart].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpLifetimeStart].operands.push(OperandLiteralNumber, "'Size'");
+        InstructionDesc[OpGroupNonUniformBallot].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformBallot].operands.push(OperandId, "X");
 
-    InstructionDesc[OpLifetimeStop].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpLifetimeStop].operands.push(OperandLiteralNumber, "'Size'");
+        InstructionDesc[OpGroupNonUniformInverseBallot].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformInverseBallot].operands.push(OperandId, "X");
 
-    InstructionDesc[OpGroupAsyncCopy].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Destination'");
-    InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Source'");
-    InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Num Elements'");
-    InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Stride'");
-    InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Event'");
+        InstructionDesc[OpGroupNonUniformBallotBitExtract].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformBallotBitExtract].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformBallotBitExtract].operands.push(OperandId, "Bit");
 
-    InstructionDesc[OpGroupWaitEvents].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupWaitEvents].operands.push(OperandId, "'Num Events'");
-    InstructionDesc[OpGroupWaitEvents].operands.push(OperandId, "'Events List'");
+        InstructionDesc[OpGroupNonUniformBallotBitCount].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformBallotBitCount].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupNonUniformBallotBitCount].operands.push(OperandId, "X");
 
-    InstructionDesc[OpGroupAll].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupAll].operands.push(OperandId, "'Predicate'");
+        InstructionDesc[OpGroupNonUniformBallotFindLSB].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformBallotFindLSB].operands.push(OperandId, "X");
 
-    InstructionDesc[OpGroupAny].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupAny].operands.push(OperandId, "'Predicate'");
+        InstructionDesc[OpGroupNonUniformBallotFindMSB].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformBallotFindMSB].operands.push(OperandId, "X");
 
-    InstructionDesc[OpGroupBroadcast].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupBroadcast].operands.push(OperandId, "'Value'");
-    InstructionDesc[OpGroupBroadcast].operands.push(OperandId, "'LocalId'");
+        InstructionDesc[OpGroupNonUniformShuffle].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformShuffle].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformShuffle].operands.push(OperandId, "'Id'");
 
-    InstructionDesc[OpGroupIAdd].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupIAdd].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupIAdd].operands.push(OperandId, "'X'");
+        InstructionDesc[OpGroupNonUniformShuffleXor].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformShuffleXor].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformShuffleXor].operands.push(OperandId, "Mask");
 
-    InstructionDesc[OpGroupFAdd].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupFAdd].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupFAdd].operands.push(OperandId, "'X'");
+        InstructionDesc[OpGroupNonUniformShuffleUp].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformShuffleUp].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformShuffleUp].operands.push(OperandId, "Offset");
 
-    InstructionDesc[OpGroupUMin].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupUMin].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupUMin].operands.push(OperandId, "'X'");
+        InstructionDesc[OpGroupNonUniformShuffleDown].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformShuffleDown].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformShuffleDown].operands.push(OperandId, "Offset");
 
-    InstructionDesc[OpGroupSMin].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupSMin].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupSMin].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformIAdd].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformIAdd].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupNonUniformIAdd].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformIAdd].operands.push(OperandId, "'ClusterSize'", true);
 
-    InstructionDesc[OpGroupFMin].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupFMin].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupFMin].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformFAdd].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformFAdd].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupNonUniformFAdd].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformFAdd].operands.push(OperandId, "'ClusterSize'", true);
 
-    InstructionDesc[OpGroupUMax].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupUMax].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupUMax].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformIMul].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformIMul].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupNonUniformIMul].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformIMul].operands.push(OperandId, "'ClusterSize'", true);
 
-    InstructionDesc[OpGroupSMax].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupSMax].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupSMax].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformFMul].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformFMul].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupNonUniformFMul].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformFMul].operands.push(OperandId, "'ClusterSize'", true);
 
-    InstructionDesc[OpGroupFMax].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupFMax].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupFMax].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformSMin].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformSMin].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupNonUniformSMin].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformSMin].operands.push(OperandId, "'ClusterSize'", true);
 
-    InstructionDesc[OpReadPipe].operands.push(OperandId, "'Pipe'");
-    InstructionDesc[OpReadPipe].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpReadPipe].operands.push(OperandId, "'Packet Size'");
-    InstructionDesc[OpReadPipe].operands.push(OperandId, "'Packet Alignment'");
+        InstructionDesc[OpGroupNonUniformUMin].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformUMin].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupNonUniformUMin].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformUMin].operands.push(OperandId, "'ClusterSize'", true);
 
-    InstructionDesc[OpWritePipe].operands.push(OperandId, "'Pipe'");
-    InstructionDesc[OpWritePipe].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpWritePipe].operands.push(OperandId, "'Packet Size'");
-    InstructionDesc[OpWritePipe].operands.push(OperandId, "'Packet Alignment'");
+        InstructionDesc[OpGroupNonUniformFMin].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformFMin].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupNonUniformFMin].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformFMin].operands.push(OperandId, "'ClusterSize'", true);
 
-    InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Pipe'");
-    InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Reserve Id'");
-    InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Index'");
-    InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Packet Size'");
-    InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Packet Alignment'");
+        InstructionDesc[OpGroupNonUniformSMax].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformSMax].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupNonUniformSMax].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformSMax].operands.push(OperandId, "'ClusterSize'", true);
 
-    InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Pipe'");
-    InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Reserve Id'");
-    InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Index'");
-    InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Packet Size'");
-    InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Packet Alignment'");
+        InstructionDesc[OpGroupNonUniformUMax].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformUMax].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupNonUniformUMax].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformUMax].operands.push(OperandId, "'ClusterSize'", true);
 
-    InstructionDesc[OpReserveReadPipePackets].operands.push(OperandId, "'Pipe'");
-    InstructionDesc[OpReserveReadPipePackets].operands.push(OperandId, "'Num Packets'");
-    InstructionDesc[OpReserveReadPipePackets].operands.push(OperandId, "'Packet Size'");
-    InstructionDesc[OpReserveReadPipePackets].operands.push(OperandId, "'Packet Alignment'");
+        InstructionDesc[OpGroupNonUniformFMax].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformFMax].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupNonUniformFMax].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformFMax].operands.push(OperandId, "'ClusterSize'", true);
 
-    InstructionDesc[OpReserveWritePipePackets].operands.push(OperandId, "'Pipe'");
-    InstructionDesc[OpReserveWritePipePackets].operands.push(OperandId, "'Num Packets'");
-    InstructionDesc[OpReserveWritePipePackets].operands.push(OperandId, "'Packet Size'");
-    InstructionDesc[OpReserveWritePipePackets].operands.push(OperandId, "'Packet Alignment'");
+        InstructionDesc[OpGroupNonUniformBitwiseAnd].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformBitwiseAnd].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupNonUniformBitwiseAnd].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformBitwiseAnd].operands.push(OperandId, "'ClusterSize'", true);
 
-    InstructionDesc[OpCommitReadPipe].operands.push(OperandId, "'Pipe'");
-    InstructionDesc[OpCommitReadPipe].operands.push(OperandId, "'Reserve Id'");
-    InstructionDesc[OpCommitReadPipe].operands.push(OperandId, "'Packet Size'");
-    InstructionDesc[OpCommitReadPipe].operands.push(OperandId, "'Packet Alignment'");
+        InstructionDesc[OpGroupNonUniformBitwiseOr].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformBitwiseOr].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupNonUniformBitwiseOr].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformBitwiseOr].operands.push(OperandId, "'ClusterSize'", true);
 
-    InstructionDesc[OpCommitWritePipe].operands.push(OperandId, "'Pipe'");
-    InstructionDesc[OpCommitWritePipe].operands.push(OperandId, "'Reserve Id'");
-    InstructionDesc[OpCommitWritePipe].operands.push(OperandId, "'Packet Size'");
-    InstructionDesc[OpCommitWritePipe].operands.push(OperandId, "'Packet Alignment'");
+        InstructionDesc[OpGroupNonUniformBitwiseXor].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformBitwiseXor].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupNonUniformBitwiseXor].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformBitwiseXor].operands.push(OperandId, "'ClusterSize'", true);
 
-    InstructionDesc[OpIsValidReserveId].operands.push(OperandId, "'Reserve Id'");
+        InstructionDesc[OpGroupNonUniformLogicalAnd].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformLogicalAnd].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupNonUniformLogicalAnd].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformLogicalAnd].operands.push(OperandId, "'ClusterSize'", true);
 
-    InstructionDesc[OpGetNumPipePackets].operands.push(OperandId, "'Pipe'");
-    InstructionDesc[OpGetNumPipePackets].operands.push(OperandId, "'Packet Size'");
-    InstructionDesc[OpGetNumPipePackets].operands.push(OperandId, "'Packet Alignment'");
+        InstructionDesc[OpGroupNonUniformLogicalOr].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformLogicalOr].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupNonUniformLogicalOr].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformLogicalOr].operands.push(OperandId, "'ClusterSize'", true);
 
-    InstructionDesc[OpGetMaxPipePackets].operands.push(OperandId, "'Pipe'");
-    InstructionDesc[OpGetMaxPipePackets].operands.push(OperandId, "'Packet Size'");
-    InstructionDesc[OpGetMaxPipePackets].operands.push(OperandId, "'Packet Alignment'");
+        InstructionDesc[OpGroupNonUniformLogicalXor].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformLogicalXor].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupNonUniformLogicalXor].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformLogicalXor].operands.push(OperandId, "'ClusterSize'", true);
 
-    InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandId, "'Pipe'");
-    InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandId, "'Num Packets'");
-    InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandId, "'Packet Size'");
-    InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandId, "'Packet Alignment'");
+        InstructionDesc[OpGroupNonUniformQuadBroadcast].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformQuadBroadcast].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformQuadBroadcast].operands.push(OperandId, "'Id'");
 
-    InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandId, "'Pipe'");
-    InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandId, "'Num Packets'");
-    InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandId, "'Packet Size'");
-    InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandId, "'Packet Alignment'");
+        InstructionDesc[OpGroupNonUniformQuadSwap].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupNonUniformQuadSwap].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformQuadSwap].operands.push(OperandId, "'Direction'");
 
-    InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandId, "'Pipe'");
-    InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandId, "'Reserve Id'");
-    InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandId, "'Packet Size'");
-    InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandId, "'Packet Alignment'");
+        InstructionDesc[OpSubgroupBallotKHR].operands.push(OperandId, "'Predicate'");
 
-    InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandId, "'Pipe'");
-    InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandId, "'Reserve Id'");
-    InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandId, "'Packet Size'");
-    InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandId, "'Packet Alignment'");
+        InstructionDesc[OpSubgroupFirstInvocationKHR].operands.push(OperandId, "'Value'");
 
-    InstructionDesc[OpBuildNDRange].operands.push(OperandId, "'GlobalWorkSize'");
-    InstructionDesc[OpBuildNDRange].operands.push(OperandId, "'LocalWorkSize'");
-    InstructionDesc[OpBuildNDRange].operands.push(OperandId, "'GlobalWorkOffset'");
+        InstructionDesc[OpSubgroupAnyKHR].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpSubgroupAnyKHR].operands.push(OperandId, "'Predicate'");
 
-    InstructionDesc[OpCaptureEventProfilingInfo].operands.push(OperandId, "'Event'");
-    InstructionDesc[OpCaptureEventProfilingInfo].operands.push(OperandId, "'Profiling Info'");
-    InstructionDesc[OpCaptureEventProfilingInfo].operands.push(OperandId, "'Value'");
+        InstructionDesc[OpSubgroupAllKHR].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpSubgroupAllKHR].operands.push(OperandId, "'Predicate'");
 
-    InstructionDesc[OpSetUserEventStatus].operands.push(OperandId, "'Event'");
-    InstructionDesc[OpSetUserEventStatus].operands.push(OperandId, "'Status'");
+        InstructionDesc[OpSubgroupAllEqualKHR].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpSubgroupAllEqualKHR].operands.push(OperandId, "'Predicate'");
 
-    InstructionDesc[OpIsValidEvent].operands.push(OperandId, "'Event'");
+        InstructionDesc[OpSubgroupReadInvocationKHR].operands.push(OperandId, "'Value'");
+        InstructionDesc[OpSubgroupReadInvocationKHR].operands.push(OperandId, "'Index'");
 
-    InstructionDesc[OpRetainEvent].operands.push(OperandId, "'Event'");
+        InstructionDesc[OpModuleProcessed].operands.push(OperandLiteralString, "'process'");
 
-    InstructionDesc[OpReleaseEvent].operands.push(OperandId, "'Event'");
+        InstructionDesc[OpGroupIAddNonUniformAMD].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupIAddNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupIAddNonUniformAMD].operands.push(OperandId, "'X'");
 
-    InstructionDesc[OpGetKernelWorkGroupSize].operands.push(OperandId, "'Invoke'");
-    InstructionDesc[OpGetKernelWorkGroupSize].operands.push(OperandId, "'Param'");
-    InstructionDesc[OpGetKernelWorkGroupSize].operands.push(OperandId, "'Param Size'");
-    InstructionDesc[OpGetKernelWorkGroupSize].operands.push(OperandId, "'Param Align'");
+        InstructionDesc[OpGroupFAddNonUniformAMD].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupFAddNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupFAddNonUniformAMD].operands.push(OperandId, "'X'");
 
-    InstructionDesc[OpGetKernelPreferredWorkGroupSizeMultiple].operands.push(OperandId, "'Invoke'");
-    InstructionDesc[OpGetKernelPreferredWorkGroupSizeMultiple].operands.push(OperandId, "'Param'");
-    InstructionDesc[OpGetKernelPreferredWorkGroupSizeMultiple].operands.push(OperandId, "'Param Size'");
-    InstructionDesc[OpGetKernelPreferredWorkGroupSizeMultiple].operands.push(OperandId, "'Param Align'");
+        InstructionDesc[OpGroupUMinNonUniformAMD].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupUMinNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupUMinNonUniformAMD].operands.push(OperandId, "'X'");
 
-    InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'ND Range'");
-    InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'Invoke'");
-    InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'Param'");
-    InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'Param Size'");
-    InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'Param Align'");
+        InstructionDesc[OpGroupSMinNonUniformAMD].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupSMinNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupSMinNonUniformAMD].operands.push(OperandId, "X");
 
-    InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'ND Range'");
-    InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'Invoke'");
-    InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'Param'");
-    InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'Param Size'");
-    InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'Param Align'");
+        InstructionDesc[OpGroupFMinNonUniformAMD].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupFMinNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupFMinNonUniformAMD].operands.push(OperandId, "X");
 
-    InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Queue'");
-    InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Flags'");
-    InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'ND Range'");
-    InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Num Events'");
-    InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Wait Events'");
-    InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Ret Event'");
-    InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Invoke'");
-    InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Param'");
-    InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Param Size'");
-    InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Param Align'");
-    InstructionDesc[OpEnqueueKernel].operands.push(OperandVariableIds, "'Local Size'");
+        InstructionDesc[OpGroupUMaxNonUniformAMD].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupUMaxNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupUMaxNonUniformAMD].operands.push(OperandId, "X");
 
-    InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Queue'");
-    InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Num Events'");
-    InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Wait Events'");
-    InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Ret Event'");
+        InstructionDesc[OpGroupSMaxNonUniformAMD].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupSMaxNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupSMaxNonUniformAMD].operands.push(OperandId, "X");
 
-    InstructionDesc[OpGroupNonUniformElect].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupFMaxNonUniformAMD].operands.push(OperandScope, "'Execution'");
+        InstructionDesc[OpGroupFMaxNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
+        InstructionDesc[OpGroupFMaxNonUniformAMD].operands.push(OperandId, "X");
 
-    InstructionDesc[OpGroupNonUniformAll].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformAll].operands.push(OperandId, "X");
+        InstructionDesc[OpFragmentMaskFetchAMD].operands.push(OperandId, "'Image'");
+        InstructionDesc[OpFragmentMaskFetchAMD].operands.push(OperandId, "'Coordinate'");
 
-    InstructionDesc[OpGroupNonUniformAny].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformAny].operands.push(OperandId, "X");
+        InstructionDesc[OpFragmentFetchAMD].operands.push(OperandId, "'Image'");
+        InstructionDesc[OpFragmentFetchAMD].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpFragmentFetchAMD].operands.push(OperandId, "'Fragment Index'");
 
-    InstructionDesc[OpGroupNonUniformAllEqual].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformAllEqual].operands.push(OperandId, "X");
+        InstructionDesc[OpGroupNonUniformPartitionNV].operands.push(OperandId, "X");
 
-    InstructionDesc[OpGroupNonUniformBroadcast].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformBroadcast].operands.push(OperandId, "X");
-    InstructionDesc[OpGroupNonUniformBroadcast].operands.push(OperandId, "ID");
+        InstructionDesc[OpTypeAccelerationStructureKHR].setResultAndType(true, false);
 
-    InstructionDesc[OpGroupNonUniformBroadcastFirst].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformBroadcastFirst].operands.push(OperandId, "X");
+        InstructionDesc[OpTraceNV].operands.push(OperandId, "'Acceleration Structure'");
+        InstructionDesc[OpTraceNV].operands.push(OperandId, "'Ray Flags'");
+        InstructionDesc[OpTraceNV].operands.push(OperandId, "'Cull Mask'");
+        InstructionDesc[OpTraceNV].operands.push(OperandId, "'SBT Record Offset'");
+        InstructionDesc[OpTraceNV].operands.push(OperandId, "'SBT Record Stride'");
+        InstructionDesc[OpTraceNV].operands.push(OperandId, "'Miss Index'");
+        InstructionDesc[OpTraceNV].operands.push(OperandId, "'Ray Origin'");
+        InstructionDesc[OpTraceNV].operands.push(OperandId, "'TMin'");
+        InstructionDesc[OpTraceNV].operands.push(OperandId, "'Ray Direction'");
+        InstructionDesc[OpTraceNV].operands.push(OperandId, "'TMax'");
+        InstructionDesc[OpTraceNV].operands.push(OperandId, "'Payload'");
+        InstructionDesc[OpTraceNV].setResultAndType(false, false);
 
-    InstructionDesc[OpGroupNonUniformBallot].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformBallot].operands.push(OperandId, "X");
+        InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Acceleration Structure'");
+        InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Ray Flags'");
+        InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Cull Mask'");
+        InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'SBT Record Offset'");
+        InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'SBT Record Stride'");
+        InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Miss Index'");
+        InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Ray Origin'");
+        InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'TMin'");
+        InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Ray Direction'");
+        InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'TMax'");
+        InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Time'");
+        InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Payload'");
+        InstructionDesc[OpTraceRayMotionNV].setResultAndType(false, false);
 
-    InstructionDesc[OpGroupNonUniformInverseBallot].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformInverseBallot].operands.push(OperandId, "X");
+        InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Acceleration Structure'");
+        InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Ray Flags'");
+        InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Cull Mask'");
+        InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'SBT Record Offset'");
+        InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'SBT Record Stride'");
+        InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Miss Index'");
+        InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Ray Origin'");
+        InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'TMin'");
+        InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Ray Direction'");
+        InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'TMax'");
+        InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Payload'");
+        InstructionDesc[OpTraceRayKHR].setResultAndType(false, false);
 
-    InstructionDesc[OpGroupNonUniformBallotBitExtract].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformBallotBitExtract].operands.push(OperandId, "X");
-    InstructionDesc[OpGroupNonUniformBallotBitExtract].operands.push(OperandId, "Bit");
+        InstructionDesc[OpReportIntersectionKHR].operands.push(OperandId, "'Hit Parameter'");
+        InstructionDesc[OpReportIntersectionKHR].operands.push(OperandId, "'Hit Kind'");
 
-    InstructionDesc[OpGroupNonUniformBallotBitCount].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformBallotBitCount].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupNonUniformBallotBitCount].operands.push(OperandId, "X");
+        InstructionDesc[OpIgnoreIntersectionNV].setResultAndType(false, false);
 
-    InstructionDesc[OpGroupNonUniformBallotFindLSB].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformBallotFindLSB].operands.push(OperandId, "X");
+        InstructionDesc[OpIgnoreIntersectionKHR].setResultAndType(false, false);
 
-    InstructionDesc[OpGroupNonUniformBallotFindMSB].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformBallotFindMSB].operands.push(OperandId, "X");
+        InstructionDesc[OpTerminateRayNV].setResultAndType(false, false);
 
-    InstructionDesc[OpGroupNonUniformShuffle].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformShuffle].operands.push(OperandId, "X");
-    InstructionDesc[OpGroupNonUniformShuffle].operands.push(OperandId, "'Id'");
+        InstructionDesc[OpTerminateRayKHR].setResultAndType(false, false);
 
-    InstructionDesc[OpGroupNonUniformShuffleXor].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformShuffleXor].operands.push(OperandId, "X");
-    InstructionDesc[OpGroupNonUniformShuffleXor].operands.push(OperandId, "Mask");
+        InstructionDesc[OpExecuteCallableNV].operands.push(OperandId, "SBT Record Index");
+        InstructionDesc[OpExecuteCallableNV].operands.push(OperandId, "CallableData ID");
+        InstructionDesc[OpExecuteCallableNV].setResultAndType(false, false);
 
-    InstructionDesc[OpGroupNonUniformShuffleUp].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformShuffleUp].operands.push(OperandId, "X");
-    InstructionDesc[OpGroupNonUniformShuffleUp].operands.push(OperandId, "Offset");
+        InstructionDesc[OpExecuteCallableKHR].operands.push(OperandId, "SBT Record Index");
+        InstructionDesc[OpExecuteCallableKHR].operands.push(OperandId, "CallableData");
+        InstructionDesc[OpExecuteCallableKHR].setResultAndType(false, false);
 
-    InstructionDesc[OpGroupNonUniformShuffleDown].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformShuffleDown].operands.push(OperandId, "X");
-    InstructionDesc[OpGroupNonUniformShuffleDown].operands.push(OperandId, "Offset");
+        InstructionDesc[OpConvertUToAccelerationStructureKHR].operands.push(OperandId, "Value");
+        InstructionDesc[OpConvertUToAccelerationStructureKHR].setResultAndType(true, true);
 
-    InstructionDesc[OpGroupNonUniformIAdd].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformIAdd].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupNonUniformIAdd].operands.push(OperandId, "X");
-    InstructionDesc[OpGroupNonUniformIAdd].operands.push(OperandId, "'ClusterSize'", true);
+        // Ray Query
+        InstructionDesc[OpTypeAccelerationStructureKHR].setResultAndType(true, false);
+        InstructionDesc[OpTypeRayQueryKHR].setResultAndType(true, false);
 
-    InstructionDesc[OpGroupNonUniformFAdd].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformFAdd].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupNonUniformFAdd].operands.push(OperandId, "X");
-    InstructionDesc[OpGroupNonUniformFAdd].operands.push(OperandId, "'ClusterSize'", true);
+        InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'AccelerationS'");
+        InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'RayFlags'");
+        InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'CullMask'");
+        InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Origin'");
+        InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Tmin'");
+        InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Direction'");
+        InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Tmax'");
+        InstructionDesc[OpRayQueryInitializeKHR].setResultAndType(false, false);
 
-    InstructionDesc[OpGroupNonUniformIMul].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformIMul].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupNonUniformIMul].operands.push(OperandId, "X");
-    InstructionDesc[OpGroupNonUniformIMul].operands.push(OperandId, "'ClusterSize'", true);
+        InstructionDesc[OpRayQueryTerminateKHR].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryTerminateKHR].setResultAndType(false, false);
 
-    InstructionDesc[OpGroupNonUniformFMul].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformFMul].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupNonUniformFMul].operands.push(OperandId, "X");
-    InstructionDesc[OpGroupNonUniformFMul].operands.push(OperandId, "'ClusterSize'", true);
+        InstructionDesc[OpRayQueryGenerateIntersectionKHR].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGenerateIntersectionKHR].operands.push(OperandId, "'THit'");
+        InstructionDesc[OpRayQueryGenerateIntersectionKHR].setResultAndType(false, false);
 
-    InstructionDesc[OpGroupNonUniformSMin].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformSMin].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupNonUniformSMin].operands.push(OperandId, "X");
-    InstructionDesc[OpGroupNonUniformSMin].operands.push(OperandId, "'ClusterSize'", true);
+        InstructionDesc[OpRayQueryConfirmIntersectionKHR].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryConfirmIntersectionKHR].setResultAndType(false, false);
 
-    InstructionDesc[OpGroupNonUniformUMin].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformUMin].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupNonUniformUMin].operands.push(OperandId, "X");
-    InstructionDesc[OpGroupNonUniformUMin].operands.push(OperandId, "'ClusterSize'", true);
+        InstructionDesc[OpRayQueryProceedKHR].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryProceedKHR].setResultAndType(true, true);
 
-    InstructionDesc[OpGroupNonUniformFMin].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformFMin].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupNonUniformFMin].operands.push(OperandId, "X");
-    InstructionDesc[OpGroupNonUniformFMin].operands.push(OperandId, "'ClusterSize'", true);
+        InstructionDesc[OpRayQueryGetIntersectionTypeKHR].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetIntersectionTypeKHR].operands.push(OperandId, "'Committed'");
+        InstructionDesc[OpRayQueryGetIntersectionTypeKHR].setResultAndType(true, true);
 
-    InstructionDesc[OpGroupNonUniformSMax].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformSMax].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupNonUniformSMax].operands.push(OperandId, "X");
-    InstructionDesc[OpGroupNonUniformSMax].operands.push(OperandId, "'ClusterSize'", true);
+        InstructionDesc[OpRayQueryGetRayTMinKHR].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetRayTMinKHR].setResultAndType(true, true);
 
-    InstructionDesc[OpGroupNonUniformUMax].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformUMax].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupNonUniformUMax].operands.push(OperandId, "X");
-    InstructionDesc[OpGroupNonUniformUMax].operands.push(OperandId, "'ClusterSize'", true);
+        InstructionDesc[OpRayQueryGetRayFlagsKHR].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetRayFlagsKHR].setResultAndType(true, true);
 
-    InstructionDesc[OpGroupNonUniformFMax].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformFMax].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupNonUniformFMax].operands.push(OperandId, "X");
-    InstructionDesc[OpGroupNonUniformFMax].operands.push(OperandId, "'ClusterSize'", true);
+        InstructionDesc[OpRayQueryGetIntersectionTKHR].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetIntersectionTKHR].operands.push(OperandId, "'Committed'");
+        InstructionDesc[OpRayQueryGetIntersectionTKHR].setResultAndType(true, true);
 
-    InstructionDesc[OpGroupNonUniformBitwiseAnd].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformBitwiseAnd].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupNonUniformBitwiseAnd].operands.push(OperandId, "X");
-    InstructionDesc[OpGroupNonUniformBitwiseAnd].operands.push(OperandId, "'ClusterSize'", true);
+        InstructionDesc[OpRayQueryGetIntersectionInstanceCustomIndexKHR].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetIntersectionInstanceCustomIndexKHR].operands.push(OperandId, "'Committed'");
+        InstructionDesc[OpRayQueryGetIntersectionInstanceCustomIndexKHR].setResultAndType(true, true);
 
-    InstructionDesc[OpGroupNonUniformBitwiseOr].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformBitwiseOr].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupNonUniformBitwiseOr].operands.push(OperandId, "X");
-    InstructionDesc[OpGroupNonUniformBitwiseOr].operands.push(OperandId, "'ClusterSize'", true);
+        InstructionDesc[OpRayQueryGetIntersectionInstanceIdKHR].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetIntersectionInstanceIdKHR].operands.push(OperandId, "'Committed'");
+        InstructionDesc[OpRayQueryGetIntersectionInstanceIdKHR].setResultAndType(true, true);
 
-    InstructionDesc[OpGroupNonUniformBitwiseXor].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformBitwiseXor].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupNonUniformBitwiseXor].operands.push(OperandId, "X");
-    InstructionDesc[OpGroupNonUniformBitwiseXor].operands.push(OperandId, "'ClusterSize'", true);
+        InstructionDesc[OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR].operands.push(OperandId, "'Committed'");
+        InstructionDesc[OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR].setResultAndType(true, true);
 
-    InstructionDesc[OpGroupNonUniformLogicalAnd].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformLogicalAnd].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupNonUniformLogicalAnd].operands.push(OperandId, "X");
-    InstructionDesc[OpGroupNonUniformLogicalAnd].operands.push(OperandId, "'ClusterSize'", true);
+        InstructionDesc[OpRayQueryGetIntersectionGeometryIndexKHR].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetIntersectionGeometryIndexKHR].operands.push(OperandId, "'Committed'");
+        InstructionDesc[OpRayQueryGetIntersectionGeometryIndexKHR].setResultAndType(true, true);
 
-    InstructionDesc[OpGroupNonUniformLogicalOr].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformLogicalOr].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupNonUniformLogicalOr].operands.push(OperandId, "X");
-    InstructionDesc[OpGroupNonUniformLogicalOr].operands.push(OperandId, "'ClusterSize'", true);
+        InstructionDesc[OpRayQueryGetIntersectionPrimitiveIndexKHR].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetIntersectionPrimitiveIndexKHR].operands.push(OperandId, "'Committed'");
+        InstructionDesc[OpRayQueryGetIntersectionPrimitiveIndexKHR].setResultAndType(true, true);
 
-    InstructionDesc[OpGroupNonUniformLogicalXor].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformLogicalXor].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupNonUniformLogicalXor].operands.push(OperandId, "X");
-    InstructionDesc[OpGroupNonUniformLogicalXor].operands.push(OperandId, "'ClusterSize'", true);
+        InstructionDesc[OpRayQueryGetIntersectionBarycentricsKHR].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetIntersectionBarycentricsKHR].operands.push(OperandId, "'Committed'");
+        InstructionDesc[OpRayQueryGetIntersectionBarycentricsKHR].setResultAndType(true, true);
 
-    InstructionDesc[OpGroupNonUniformQuadBroadcast].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformQuadBroadcast].operands.push(OperandId, "X");
-    InstructionDesc[OpGroupNonUniformQuadBroadcast].operands.push(OperandId, "'Id'");
+        InstructionDesc[OpRayQueryGetIntersectionFrontFaceKHR].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetIntersectionFrontFaceKHR].operands.push(OperandId, "'Committed'");
+        InstructionDesc[OpRayQueryGetIntersectionFrontFaceKHR].setResultAndType(true, true);
 
-    InstructionDesc[OpGroupNonUniformQuadSwap].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupNonUniformQuadSwap].operands.push(OperandId, "X");
-    InstructionDesc[OpGroupNonUniformQuadSwap].operands.push(OperandId, "'Direction'");
+        InstructionDesc[OpRayQueryGetIntersectionCandidateAABBOpaqueKHR].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetIntersectionCandidateAABBOpaqueKHR].setResultAndType(true, true);
 
-    InstructionDesc[OpSubgroupBallotKHR].operands.push(OperandId, "'Predicate'");
+        InstructionDesc[OpRayQueryGetIntersectionObjectRayDirectionKHR].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetIntersectionObjectRayDirectionKHR].operands.push(OperandId, "'Committed'");
+        InstructionDesc[OpRayQueryGetIntersectionObjectRayDirectionKHR].setResultAndType(true, true);
 
-    InstructionDesc[OpSubgroupFirstInvocationKHR].operands.push(OperandId, "'Value'");
+        InstructionDesc[OpRayQueryGetIntersectionObjectRayOriginKHR].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetIntersectionObjectRayOriginKHR].operands.push(OperandId, "'Committed'");
+        InstructionDesc[OpRayQueryGetIntersectionObjectRayOriginKHR].setResultAndType(true, true);
 
-    InstructionDesc[OpSubgroupAnyKHR].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpSubgroupAnyKHR].operands.push(OperandId, "'Predicate'");
+        InstructionDesc[OpRayQueryGetWorldRayDirectionKHR].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetWorldRayDirectionKHR].setResultAndType(true, true);
 
-    InstructionDesc[OpSubgroupAllKHR].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpSubgroupAllKHR].operands.push(OperandId, "'Predicate'");
+        InstructionDesc[OpRayQueryGetWorldRayOriginKHR].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetWorldRayOriginKHR].setResultAndType(true, true);
 
-    InstructionDesc[OpSubgroupAllEqualKHR].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpSubgroupAllEqualKHR].operands.push(OperandId, "'Predicate'");
+        InstructionDesc[OpRayQueryGetIntersectionObjectToWorldKHR].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetIntersectionObjectToWorldKHR].operands.push(OperandId, "'Committed'");
+        InstructionDesc[OpRayQueryGetIntersectionObjectToWorldKHR].setResultAndType(true, true);
 
-    InstructionDesc[OpSubgroupReadInvocationKHR].operands.push(OperandId, "'Value'");
-    InstructionDesc[OpSubgroupReadInvocationKHR].operands.push(OperandId, "'Index'");
+        InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].operands.push(OperandId, "'Committed'");
+        InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].setResultAndType(true, true);
 
-    InstructionDesc[OpModuleProcessed].operands.push(OperandLiteralString, "'process'");
+        InstructionDesc[OpRayQueryGetIntersectionTriangleVertexPositionsKHR].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetIntersectionTriangleVertexPositionsKHR].operands.push(OperandId, "'Committed'");
+        InstructionDesc[OpRayQueryGetIntersectionTriangleVertexPositionsKHR].setResultAndType(true, true);
 
-    InstructionDesc[OpGroupIAddNonUniformAMD].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupIAddNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupIAddNonUniformAMD].operands.push(OperandId, "'X'");
+        InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Sampled Image'");
+        InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Granularity'");
+        InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Coarse'");
+        InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandVariableIds, "", true);
 
-    InstructionDesc[OpGroupFAddNonUniformAMD].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupFAddNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupFAddNonUniformAMD].operands.push(OperandId, "'X'");
+        InstructionDesc[OpWritePackedPrimitiveIndices4x8NV].operands.push(OperandId, "'Index Offset'");
+        InstructionDesc[OpWritePackedPrimitiveIndices4x8NV].operands.push(OperandId, "'Packed Indices'");
 
-    InstructionDesc[OpGroupUMinNonUniformAMD].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupUMinNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupUMinNonUniformAMD].operands.push(OperandId, "'X'");
+        InstructionDesc[OpEmitMeshTasksEXT].operands.push(OperandId, "'groupCountX'");
+        InstructionDesc[OpEmitMeshTasksEXT].operands.push(OperandId, "'groupCountY'");
+        InstructionDesc[OpEmitMeshTasksEXT].operands.push(OperandId, "'groupCountZ'");
+        InstructionDesc[OpEmitMeshTasksEXT].operands.push(OperandId, "'Payload'");
+        InstructionDesc[OpEmitMeshTasksEXT].setResultAndType(false, false);
 
-    InstructionDesc[OpGroupSMinNonUniformAMD].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupSMinNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupSMinNonUniformAMD].operands.push(OperandId, "X");
+        InstructionDesc[OpSetMeshOutputsEXT].operands.push(OperandId, "'vertexCount'");
+        InstructionDesc[OpSetMeshOutputsEXT].operands.push(OperandId, "'primitiveCount'");
+        InstructionDesc[OpSetMeshOutputsEXT].setResultAndType(false, false);
 
-    InstructionDesc[OpGroupFMinNonUniformAMD].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupFMinNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupFMinNonUniformAMD].operands.push(OperandId, "X");
 
-    InstructionDesc[OpGroupUMaxNonUniformAMD].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupUMaxNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupUMaxNonUniformAMD].operands.push(OperandId, "X");
+        InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Component Type'");
+        InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Scope'");
+        InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Rows'");
+        InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Columns'");
 
-    InstructionDesc[OpGroupSMaxNonUniformAMD].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupSMaxNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupSMaxNonUniformAMD].operands.push(OperandId, "X");
+        InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandId, "'Stride'");
+        InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandId, "'Column Major'");
+        InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandMemoryAccess, "'Memory Access'");
+        InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandLiteralNumber, "", true);
+        InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandId, "", true);
 
-    InstructionDesc[OpGroupFMaxNonUniformAMD].operands.push(OperandScope, "'Execution'");
-    InstructionDesc[OpGroupFMaxNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
-    InstructionDesc[OpGroupFMaxNonUniformAMD].operands.push(OperandId, "X");
+        InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "'Object'");
+        InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "'Stride'");
+        InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "'Column Major'");
+        InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandMemoryAccess, "'Memory Access'");
+        InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandLiteralNumber, "", true);
+        InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "", true);
 
-    InstructionDesc[OpFragmentMaskFetchAMD].operands.push(OperandId, "'Image'");
-    InstructionDesc[OpFragmentMaskFetchAMD].operands.push(OperandId, "'Coordinate'");
+        InstructionDesc[OpCooperativeMatrixMulAddNV].operands.push(OperandId, "'A'");
+        InstructionDesc[OpCooperativeMatrixMulAddNV].operands.push(OperandId, "'B'");
+        InstructionDesc[OpCooperativeMatrixMulAddNV].operands.push(OperandId, "'C'");
 
-    InstructionDesc[OpFragmentFetchAMD].operands.push(OperandId, "'Image'");
-    InstructionDesc[OpFragmentFetchAMD].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpFragmentFetchAMD].operands.push(OperandId, "'Fragment Index'");
+        InstructionDesc[OpCooperativeMatrixLengthNV].operands.push(OperandId, "'Type'");
 
-    InstructionDesc[OpGroupNonUniformPartitionNV].operands.push(OperandId, "X");
+        InstructionDesc[OpTypeCooperativeMatrixKHR].operands.push(OperandId, "'Component Type'");
+        InstructionDesc[OpTypeCooperativeMatrixKHR].operands.push(OperandId, "'Scope'");
+        InstructionDesc[OpTypeCooperativeMatrixKHR].operands.push(OperandId, "'Rows'");
+        InstructionDesc[OpTypeCooperativeMatrixKHR].operands.push(OperandId, "'Columns'");
+        InstructionDesc[OpTypeCooperativeMatrixKHR].operands.push(OperandId, "'Use'");
 
-    InstructionDesc[OpTypeAccelerationStructureKHR].setResultAndType(true, false);
+        InstructionDesc[OpCooperativeMatrixLoadKHR].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpCooperativeMatrixLoadKHR].operands.push(OperandId, "'Memory Layout'");
+        InstructionDesc[OpCooperativeMatrixLoadKHR].operands.push(OperandId, "'Stride'");
+        InstructionDesc[OpCooperativeMatrixLoadKHR].operands.push(OperandMemoryAccess, "'Memory Access'");
+        InstructionDesc[OpCooperativeMatrixLoadKHR].operands.push(OperandLiteralNumber, "", true);
+        InstructionDesc[OpCooperativeMatrixLoadKHR].operands.push(OperandId, "", true);
 
-    InstructionDesc[OpTraceNV].operands.push(OperandId, "'Acceleration Structure'");
-    InstructionDesc[OpTraceNV].operands.push(OperandId, "'Ray Flags'");
-    InstructionDesc[OpTraceNV].operands.push(OperandId, "'Cull Mask'");
-    InstructionDesc[OpTraceNV].operands.push(OperandId, "'SBT Record Offset'");
-    InstructionDesc[OpTraceNV].operands.push(OperandId, "'SBT Record Stride'");
-    InstructionDesc[OpTraceNV].operands.push(OperandId, "'Miss Index'");
-    InstructionDesc[OpTraceNV].operands.push(OperandId, "'Ray Origin'");
-    InstructionDesc[OpTraceNV].operands.push(OperandId, "'TMin'");
-    InstructionDesc[OpTraceNV].operands.push(OperandId, "'Ray Direction'");
-    InstructionDesc[OpTraceNV].operands.push(OperandId, "'TMax'");
-    InstructionDesc[OpTraceNV].operands.push(OperandId, "'Payload'");
-    InstructionDesc[OpTraceNV].setResultAndType(false, false);
+        InstructionDesc[OpCooperativeMatrixStoreKHR].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpCooperativeMatrixStoreKHR].operands.push(OperandId, "'Object'");
+        InstructionDesc[OpCooperativeMatrixStoreKHR].operands.push(OperandId, "'Memory Layout'");
+        InstructionDesc[OpCooperativeMatrixStoreKHR].operands.push(OperandId, "'Stride'");
+        InstructionDesc[OpCooperativeMatrixStoreKHR].operands.push(OperandMemoryAccess, "'Memory Access'");
+        InstructionDesc[OpCooperativeMatrixStoreKHR].operands.push(OperandLiteralNumber, "", true);
+        InstructionDesc[OpCooperativeMatrixStoreKHR].operands.push(OperandId, "", true);
 
-    InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Acceleration Structure'");
-    InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Ray Flags'");
-    InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Cull Mask'");
-    InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'SBT Record Offset'");
-    InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'SBT Record Stride'");
-    InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Miss Index'");
-    InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Ray Origin'");
-    InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'TMin'");
-    InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Ray Direction'");
-    InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'TMax'");
-    InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Time'");
-    InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Payload'");
-    InstructionDesc[OpTraceRayMotionNV].setResultAndType(false, false);
+        InstructionDesc[OpCooperativeMatrixMulAddKHR].operands.push(OperandId, "'A'");
+        InstructionDesc[OpCooperativeMatrixMulAddKHR].operands.push(OperandId, "'B'");
+        InstructionDesc[OpCooperativeMatrixMulAddKHR].operands.push(OperandId, "'C'");
+        InstructionDesc[OpCooperativeMatrixMulAddKHR].operands.push(OperandCooperativeMatrixOperands, "'Cooperative Matrix Operands'", true);
 
-    InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Acceleration Structure'");
-    InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Ray Flags'");
-    InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Cull Mask'");
-    InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'SBT Record Offset'");
-    InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'SBT Record Stride'");
-    InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Miss Index'");
-    InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Ray Origin'");
-    InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'TMin'");
-    InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Ray Direction'");
-    InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'TMax'");
-    InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Payload'");
-    InstructionDesc[OpTraceRayKHR].setResultAndType(false, false);
+        InstructionDesc[OpCooperativeMatrixLengthKHR].operands.push(OperandId, "'Type'");
 
-    InstructionDesc[OpReportIntersectionKHR].operands.push(OperandId, "'Hit Parameter'");
-    InstructionDesc[OpReportIntersectionKHR].operands.push(OperandId, "'Hit Kind'");
+        InstructionDesc[OpDemoteToHelperInvocationEXT].setResultAndType(false, false);
 
-    InstructionDesc[OpIgnoreIntersectionNV].setResultAndType(false, false);
+        InstructionDesc[OpReadClockKHR].operands.push(OperandScope, "'Scope'");
 
-    InstructionDesc[OpIgnoreIntersectionKHR].setResultAndType(false, false);
+        InstructionDesc[OpTypeHitObjectNV].setResultAndType(true, false);
 
-    InstructionDesc[OpTerminateRayNV].setResultAndType(false, false);
+        InstructionDesc[OpHitObjectGetShaderRecordBufferHandleNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectGetShaderRecordBufferHandleNV].setResultAndType(true, true);
 
-    InstructionDesc[OpTerminateRayKHR].setResultAndType(false, false);
-    
-    InstructionDesc[OpExecuteCallableNV].operands.push(OperandId, "SBT Record Index");
-    InstructionDesc[OpExecuteCallableNV].operands.push(OperandId, "CallableData ID");
-    InstructionDesc[OpExecuteCallableNV].setResultAndType(false, false);
+        InstructionDesc[OpReorderThreadWithHintNV].operands.push(OperandId, "'Hint'");
+        InstructionDesc[OpReorderThreadWithHintNV].operands.push(OperandId, "'Bits'");
+        InstructionDesc[OpReorderThreadWithHintNV].setResultAndType(false, false);
 
-    InstructionDesc[OpExecuteCallableKHR].operands.push(OperandId, "SBT Record Index");
-    InstructionDesc[OpExecuteCallableKHR].operands.push(OperandId, "CallableData");
-    InstructionDesc[OpExecuteCallableKHR].setResultAndType(false, false);
+        InstructionDesc[OpReorderThreadWithHitObjectNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpReorderThreadWithHitObjectNV].operands.push(OperandId, "'Hint'");
+        InstructionDesc[OpReorderThreadWithHitObjectNV].operands.push(OperandId, "'Bits'");
+        InstructionDesc[OpReorderThreadWithHitObjectNV].setResultAndType(false, false);
 
-    InstructionDesc[OpConvertUToAccelerationStructureKHR].operands.push(OperandId, "Value");
-    InstructionDesc[OpConvertUToAccelerationStructureKHR].setResultAndType(true, true);
+        InstructionDesc[OpHitObjectGetCurrentTimeNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectGetCurrentTimeNV].setResultAndType(true, true);
 
-    // Ray Query
-    InstructionDesc[OpTypeAccelerationStructureKHR].setResultAndType(true, false);
-    InstructionDesc[OpTypeRayQueryKHR].setResultAndType(true, false);
+        InstructionDesc[OpHitObjectGetHitKindNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectGetHitKindNV].setResultAndType(true, true);
 
-    InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'RayQuery'");
-    InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'AccelerationS'");
-    InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'RayFlags'");
-    InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'CullMask'");
-    InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Origin'");
-    InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Tmin'");
-    InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Direction'");
-    InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Tmax'");
-    InstructionDesc[OpRayQueryInitializeKHR].setResultAndType(false, false);
+        InstructionDesc[OpHitObjectGetPrimitiveIndexNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectGetPrimitiveIndexNV].setResultAndType(true, true);
 
-    InstructionDesc[OpRayQueryTerminateKHR].operands.push(OperandId, "'RayQuery'");
-    InstructionDesc[OpRayQueryTerminateKHR].setResultAndType(false, false);
+        InstructionDesc[OpHitObjectGetGeometryIndexNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectGetGeometryIndexNV].setResultAndType(true, true);
 
-    InstructionDesc[OpRayQueryGenerateIntersectionKHR].operands.push(OperandId, "'RayQuery'");
-    InstructionDesc[OpRayQueryGenerateIntersectionKHR].operands.push(OperandId, "'THit'");
-    InstructionDesc[OpRayQueryGenerateIntersectionKHR].setResultAndType(false, false);
+        InstructionDesc[OpHitObjectGetInstanceIdNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectGetInstanceIdNV].setResultAndType(true, true);
 
-    InstructionDesc[OpRayQueryConfirmIntersectionKHR].operands.push(OperandId, "'RayQuery'");
-    InstructionDesc[OpRayQueryConfirmIntersectionKHR].setResultAndType(false, false);
+        InstructionDesc[OpHitObjectGetInstanceCustomIndexNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectGetInstanceCustomIndexNV].setResultAndType(true, true);
 
-    InstructionDesc[OpRayQueryProceedKHR].operands.push(OperandId, "'RayQuery'");
-    InstructionDesc[OpRayQueryProceedKHR].setResultAndType(true, true);
+        InstructionDesc[OpHitObjectGetObjectRayDirectionNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectGetObjectRayDirectionNV].setResultAndType(true, true);
 
-    InstructionDesc[OpRayQueryGetIntersectionTypeKHR].operands.push(OperandId, "'RayQuery'");
-    InstructionDesc[OpRayQueryGetIntersectionTypeKHR].operands.push(OperandId, "'Committed'");
-    InstructionDesc[OpRayQueryGetIntersectionTypeKHR].setResultAndType(true, true);
+        InstructionDesc[OpHitObjectGetObjectRayOriginNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectGetObjectRayOriginNV].setResultAndType(true, true);
 
-    InstructionDesc[OpRayQueryGetRayTMinKHR].operands.push(OperandId, "'RayQuery'");
-    InstructionDesc[OpRayQueryGetRayTMinKHR].setResultAndType(true, true);
+        InstructionDesc[OpHitObjectGetWorldRayDirectionNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectGetWorldRayDirectionNV].setResultAndType(true, true);
 
-    InstructionDesc[OpRayQueryGetRayFlagsKHR].operands.push(OperandId, "'RayQuery'");
-    InstructionDesc[OpRayQueryGetRayFlagsKHR].setResultAndType(true, true);
+        InstructionDesc[OpHitObjectGetWorldRayOriginNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectGetWorldRayOriginNV].setResultAndType(true, true);
 
-    InstructionDesc[OpRayQueryGetIntersectionTKHR].operands.push(OperandId, "'RayQuery'");
-    InstructionDesc[OpRayQueryGetIntersectionTKHR].operands.push(OperandId, "'Committed'");
-    InstructionDesc[OpRayQueryGetIntersectionTKHR].setResultAndType(true, true);
+        InstructionDesc[OpHitObjectGetWorldToObjectNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectGetWorldToObjectNV].setResultAndType(true, true);
 
-    InstructionDesc[OpRayQueryGetIntersectionInstanceCustomIndexKHR].operands.push(OperandId, "'RayQuery'");
-    InstructionDesc[OpRayQueryGetIntersectionInstanceCustomIndexKHR].operands.push(OperandId, "'Committed'");
-    InstructionDesc[OpRayQueryGetIntersectionInstanceCustomIndexKHR].setResultAndType(true, true);
+        InstructionDesc[OpHitObjectGetObjectToWorldNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectGetObjectToWorldNV].setResultAndType(true, true);
 
-    InstructionDesc[OpRayQueryGetIntersectionInstanceIdKHR].operands.push(OperandId, "'RayQuery'");
-    InstructionDesc[OpRayQueryGetIntersectionInstanceIdKHR].operands.push(OperandId, "'Committed'");
-    InstructionDesc[OpRayQueryGetIntersectionInstanceIdKHR].setResultAndType(true, true);
+        InstructionDesc[OpHitObjectGetRayTMaxNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectGetRayTMaxNV].setResultAndType(true, true);
 
-    InstructionDesc[OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR].operands.push(OperandId, "'RayQuery'");
-    InstructionDesc[OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR].operands.push(OperandId, "'Committed'");
-    InstructionDesc[OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR].setResultAndType(true, true);
+        InstructionDesc[OpHitObjectGetRayTMinNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectGetRayTMinNV].setResultAndType(true, true);
 
-    InstructionDesc[OpRayQueryGetIntersectionGeometryIndexKHR].operands.push(OperandId, "'RayQuery'");
-    InstructionDesc[OpRayQueryGetIntersectionGeometryIndexKHR].operands.push(OperandId, "'Committed'");
-    InstructionDesc[OpRayQueryGetIntersectionGeometryIndexKHR].setResultAndType(true, true);
+        InstructionDesc[OpHitObjectGetShaderBindingTableRecordIndexNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectGetShaderBindingTableRecordIndexNV].setResultAndType(true, true);
 
-    InstructionDesc[OpRayQueryGetIntersectionPrimitiveIndexKHR].operands.push(OperandId, "'RayQuery'");
-    InstructionDesc[OpRayQueryGetIntersectionPrimitiveIndexKHR].operands.push(OperandId, "'Committed'");
-    InstructionDesc[OpRayQueryGetIntersectionPrimitiveIndexKHR].setResultAndType(true, true);
+        InstructionDesc[OpHitObjectIsEmptyNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectIsEmptyNV].setResultAndType(true, true);
 
-    InstructionDesc[OpRayQueryGetIntersectionBarycentricsKHR].operands.push(OperandId, "'RayQuery'");
-    InstructionDesc[OpRayQueryGetIntersectionBarycentricsKHR].operands.push(OperandId, "'Committed'");
-    InstructionDesc[OpRayQueryGetIntersectionBarycentricsKHR].setResultAndType(true, true);
+        InstructionDesc[OpHitObjectIsHitNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectIsHitNV].setResultAndType(true, true);
 
-    InstructionDesc[OpRayQueryGetIntersectionFrontFaceKHR].operands.push(OperandId, "'RayQuery'");
-    InstructionDesc[OpRayQueryGetIntersectionFrontFaceKHR].operands.push(OperandId, "'Committed'");
-    InstructionDesc[OpRayQueryGetIntersectionFrontFaceKHR].setResultAndType(true, true);
+        InstructionDesc[OpHitObjectIsMissNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectIsMissNV].setResultAndType(true, true);
 
-    InstructionDesc[OpRayQueryGetIntersectionCandidateAABBOpaqueKHR].operands.push(OperandId, "'RayQuery'");
-    InstructionDesc[OpRayQueryGetIntersectionCandidateAABBOpaqueKHR].setResultAndType(true, true);
+        InstructionDesc[OpHitObjectGetAttributesNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectGetAttributesNV].operands.push(OperandId, "'HitObjectAttribute'");
+        InstructionDesc[OpHitObjectGetAttributesNV].setResultAndType(false, false);
 
-    InstructionDesc[OpRayQueryGetIntersectionObjectRayDirectionKHR].operands.push(OperandId, "'RayQuery'");
-    InstructionDesc[OpRayQueryGetIntersectionObjectRayDirectionKHR].operands.push(OperandId, "'Committed'");
-    InstructionDesc[OpRayQueryGetIntersectionObjectRayDirectionKHR].setResultAndType(true, true);
+        InstructionDesc[OpHitObjectExecuteShaderNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectExecuteShaderNV].operands.push(OperandId, "'Payload'");
+        InstructionDesc[OpHitObjectExecuteShaderNV].setResultAndType(false, false);
 
-    InstructionDesc[OpRayQueryGetIntersectionObjectRayOriginKHR].operands.push(OperandId, "'RayQuery'");
-    InstructionDesc[OpRayQueryGetIntersectionObjectRayOriginKHR].operands.push(OperandId, "'Committed'");
-    InstructionDesc[OpRayQueryGetIntersectionObjectRayOriginKHR].setResultAndType(true, true);
+        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'Acceleration Structure'");
+        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'InstanceId'");
+        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'PrimitiveId'");
+        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'GeometryIndex'");
+        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'HitKind'");
+        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'SBT Record Offset'");
+        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'SBT Record Stride'");
+        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'Origin'");
+        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'TMin'");
+        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'Direction'");
+        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'TMax'");
+        InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'HitObject Attribute'");
+        InstructionDesc[OpHitObjectRecordHitNV].setResultAndType(false, false);
 
-    InstructionDesc[OpRayQueryGetWorldRayDirectionKHR].operands.push(OperandId, "'RayQuery'");
-    InstructionDesc[OpRayQueryGetWorldRayDirectionKHR].setResultAndType(true, true);
+        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'Acceleration Structure'");
+        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'InstanceId'");
+        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'PrimitiveId'");
+        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'GeometryIndex'");
+        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'HitKind'");
+        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'SBT Record Offset'");
+        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'SBT Record Stride'");
+        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'Origin'");
+        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'TMin'");
+        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'Direction'");
+        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'TMax'");
+        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'Current Time'");
+        InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'HitObject Attribute'");
+        InstructionDesc[OpHitObjectRecordHitMotionNV].setResultAndType(false, false);
 
-    InstructionDesc[OpRayQueryGetWorldRayOriginKHR].operands.push(OperandId, "'RayQuery'");
-    InstructionDesc[OpRayQueryGetWorldRayOriginKHR].setResultAndType(true, true);
+        InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'Acceleration Structure'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'InstanceId'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'PrimitiveId'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'GeometryIndex'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'HitKind'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'SBT Record Index'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'Origin'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'TMin'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'Direction'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'TMax'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'HitObject Attribute'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexNV].setResultAndType(false, false);
 
-    InstructionDesc[OpRayQueryGetIntersectionObjectToWorldKHR].operands.push(OperandId, "'RayQuery'");
-    InstructionDesc[OpRayQueryGetIntersectionObjectToWorldKHR].operands.push(OperandId, "'Committed'");
-    InstructionDesc[OpRayQueryGetIntersectionObjectToWorldKHR].setResultAndType(true, true);
+        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'Acceleration Structure'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'InstanceId'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'PrimitiveId'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'GeometryIndex'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'HitKind'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'SBT Record Index'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'Origin'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'TMin'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'Direction'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'TMax'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'Current Time'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'HitObject Attribute'");
+        InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].setResultAndType(false, false);
 
-    InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].operands.push(OperandId, "'RayQuery'");
-    InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].operands.push(OperandId, "'Committed'");
-    InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].setResultAndType(true, true);
+        InstructionDesc[OpHitObjectRecordMissNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectRecordMissNV].operands.push(OperandId, "'SBT Index'");
+        InstructionDesc[OpHitObjectRecordMissNV].operands.push(OperandId, "'Origin'");
+        InstructionDesc[OpHitObjectRecordMissNV].operands.push(OperandId, "'TMin'");
+        InstructionDesc[OpHitObjectRecordMissNV].operands.push(OperandId, "'Direction'");
+        InstructionDesc[OpHitObjectRecordMissNV].operands.push(OperandId, "'TMax'");
+        InstructionDesc[OpHitObjectRecordMissNV].setResultAndType(false, false);
 
-    InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Sampled Image'");
-    InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Coordinate'");
-    InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Granularity'");
-    InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Coarse'");
-    InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandImageOperands, "", true);
-    InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandVariableIds, "", true);
-    
-    InstructionDesc[OpWritePackedPrimitiveIndices4x8NV].operands.push(OperandId, "'Index Offset'");
-    InstructionDesc[OpWritePackedPrimitiveIndices4x8NV].operands.push(OperandId, "'Packed Indices'");
+        InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'SBT Index'");
+        InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'Origin'");
+        InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'TMin'");
+        InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'Direction'");
+        InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'TMax'");
+        InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'Current Time'");
+        InstructionDesc[OpHitObjectRecordMissMotionNV].setResultAndType(false, false);
 
-    InstructionDesc[OpEmitMeshTasksEXT].operands.push(OperandId, "'groupCountX'");
-    InstructionDesc[OpEmitMeshTasksEXT].operands.push(OperandId, "'groupCountY'");
-    InstructionDesc[OpEmitMeshTasksEXT].operands.push(OperandId, "'groupCountZ'");
-    InstructionDesc[OpEmitMeshTasksEXT].operands.push(OperandId, "'Payload'");
-    InstructionDesc[OpEmitMeshTasksEXT].setResultAndType(false, false);
+        InstructionDesc[OpHitObjectRecordEmptyNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectRecordEmptyNV].setResultAndType(false, false);
 
-    InstructionDesc[OpSetMeshOutputsEXT].operands.push(OperandId, "'vertexCount'");
-    InstructionDesc[OpSetMeshOutputsEXT].operands.push(OperandId, "'primitiveCount'");
-    InstructionDesc[OpSetMeshOutputsEXT].setResultAndType(false, false);
+        InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'Acceleration Structure'");
+        InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'RayFlags'");
+        InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'Cullmask'");
+        InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'SBT Record Offset'");
+        InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'SBT Record Stride'");
+        InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'Miss Index'");
+        InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'Origin'");
+        InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'TMin'");
+        InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'Direction'");
+        InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'TMax'");
+        InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'Payload'");
+        InstructionDesc[OpHitObjectTraceRayNV].setResultAndType(false, false);
 
+        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Acceleration Structure'");
+        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'RayFlags'");
+        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Cullmask'");
+        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'SBT Record Offset'");
+        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'SBT Record Stride'");
+        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Miss Index'");
+        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Origin'");
+        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'TMin'");
+        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Direction'");
+        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'TMax'");
+        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Time'");
+        InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Payload'");
+        InstructionDesc[OpHitObjectTraceRayMotionNV].setResultAndType(false, false);
 
-    InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Component Type'");
-    InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Scope'");
-    InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Rows'");
-    InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Columns'");
+        InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].operands.push(OperandId, "'Acceleration Structure'");
+        InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].operands.push(OperandId, "'Instance ID'");
+        InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].operands.push(OperandId, "'Geometry Index'");
+        InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].operands.push(OperandId, "'Primitive Index'");
+        InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].operands.push(OperandId, "'Barycentrics'");
+        InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].setResultAndType(true, true);
 
-    InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandId, "'Stride'");
-    InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandId, "'Column Major'");
-    InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandMemoryAccess, "'Memory Access'");
-    InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandLiteralNumber, "", true);
-    InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandId, "", true);
+        InstructionDesc[OpFetchMicroTriangleVertexPositionNV].operands.push(OperandId, "'Acceleration Structure'");
+        InstructionDesc[OpFetchMicroTriangleVertexPositionNV].operands.push(OperandId, "'Instance ID'");
+        InstructionDesc[OpFetchMicroTriangleVertexPositionNV].operands.push(OperandId, "'Geometry Index'");
+        InstructionDesc[OpFetchMicroTriangleVertexPositionNV].operands.push(OperandId, "'Primitive Index'");
+        InstructionDesc[OpFetchMicroTriangleVertexPositionNV].operands.push(OperandId, "'Barycentrics'");
+        InstructionDesc[OpFetchMicroTriangleVertexPositionNV].setResultAndType(true, true);
 
-    InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "'Pointer'");
-    InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "'Object'");
-    InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "'Stride'");
-    InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "'Column Major'");
-    InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandMemoryAccess, "'Memory Access'");
-    InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandLiteralNumber, "", true);
-    InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "", true);
+        InstructionDesc[OpColorAttachmentReadEXT].operands.push(OperandId, "'Attachment'");
+        InstructionDesc[OpColorAttachmentReadEXT].operands.push(OperandId, "'Sample'", true);
+        InstructionDesc[OpStencilAttachmentReadEXT].operands.push(OperandId, "'Sample'", true);
+        InstructionDesc[OpDepthAttachmentReadEXT].operands.push(OperandId, "'Sample'", true);
 
-    InstructionDesc[OpCooperativeMatrixMulAddNV].operands.push(OperandId, "'A'");
-    InstructionDesc[OpCooperativeMatrixMulAddNV].operands.push(OperandId, "'B'");
-    InstructionDesc[OpCooperativeMatrixMulAddNV].operands.push(OperandId, "'C'");
+        InstructionDesc[OpImageSampleWeightedQCOM].operands.push(OperandId, "'source texture'");
+        InstructionDesc[OpImageSampleWeightedQCOM].operands.push(OperandId, "'texture coordinates'");
+        InstructionDesc[OpImageSampleWeightedQCOM].operands.push(OperandId, "'weights texture'");
+        InstructionDesc[OpImageSampleWeightedQCOM].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageSampleWeightedQCOM].setResultAndType(true, true);
 
-    InstructionDesc[OpCooperativeMatrixLengthNV].operands.push(OperandId, "'Type'");
+        InstructionDesc[OpImageBoxFilterQCOM].operands.push(OperandId, "'source texture'");
+        InstructionDesc[OpImageBoxFilterQCOM].operands.push(OperandId, "'texture coordinates'");
+        InstructionDesc[OpImageBoxFilterQCOM].operands.push(OperandId, "'box size'");
+        InstructionDesc[OpImageBoxFilterQCOM].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageBoxFilterQCOM].setResultAndType(true, true);
 
-    InstructionDesc[OpDemoteToHelperInvocationEXT].setResultAndType(false, false);
+        InstructionDesc[OpImageBlockMatchSADQCOM].operands.push(OperandId, "'target texture'");
+        InstructionDesc[OpImageBlockMatchSADQCOM].operands.push(OperandId, "'target coordinates'");
+        InstructionDesc[OpImageBlockMatchSADQCOM].operands.push(OperandId, "'reference texture'");
+        InstructionDesc[OpImageBlockMatchSADQCOM].operands.push(OperandId, "'reference coordinates'");
+        InstructionDesc[OpImageBlockMatchSADQCOM].operands.push(OperandId, "'block size'");
+        InstructionDesc[OpImageBlockMatchSADQCOM].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageBlockMatchSADQCOM].setResultAndType(true, true);
 
-    InstructionDesc[OpReadClockKHR].operands.push(OperandScope, "'Scope'");
+        InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandId, "'target texture'");
+        InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandId, "'target coordinates'");
+        InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandId, "'reference texture'");
+        InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandId, "'reference coordinates'");
+        InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandId, "'block size'");
+        InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandImageOperands, "", true);
+        InstructionDesc[OpImageBlockMatchSSDQCOM].setResultAndType(true, true);
+    });
 }
 
 }; // end spv namespace
diff --git a/SPIRV/doc.h b/SPIRV/doc.h
index 2a0b28c..b60ad34 100644
--- a/SPIRV/doc.h
+++ b/SPIRV/doc.h
@@ -156,6 +156,7 @@
     OperandKernelEnqueueFlags,
     OperandKernelProfilingInfo,
     OperandCapability,
+    OperandCooperativeMatrixOperands,
 
     OperandOpcode,
 
@@ -190,15 +191,15 @@
 // Parameterize an enumerant
 class EnumParameters {
 public:
-    EnumParameters() : desc(0) { }
+    EnumParameters() : desc(nullptr) { }
     const char* desc;
 };
 
 // Parameterize a set of enumerants that form an enum
 class EnumDefinition : public EnumParameters {
 public:
-    EnumDefinition() : 
-        ceiling(0), bitmask(false), getName(0), enumParams(0), operandParams(0) { }
+    EnumDefinition() :
+        ceiling(0), bitmask(false), getName(nullptr), enumParams(nullptr), operandParams(nullptr) { }
     void set(int ceil, const char* (*name)(int), EnumParameters* ep, bool mask = false)
     {
         ceiling = ceil;
diff --git a/SPIRV/hex_float.h b/SPIRV/hex_float.h
index 8be8e9f..785e8af 100644
--- a/SPIRV/hex_float.h
+++ b/SPIRV/hex_float.h
@@ -23,19 +23,6 @@
 #include <limits>
 #include <sstream>
 
-#if defined(_MSC_VER) && _MSC_VER < 1800
-namespace std {
-bool isnan(double f)
-{
-  return ::_isnan(f) != 0;
-}
-bool isinf(double f)
-{
-  return ::_finite(f) == 0;
-}
-}
-#endif
-
 #include "bitutils.h"
 
 namespace spvutils {
diff --git a/SPIRV/spirv.hpp b/SPIRV/spirv.hpp
index 0e40544..02c1ede 100644
--- a/SPIRV/spirv.hpp
+++ b/SPIRV/spirv.hpp
@@ -1,2533 +1,2796 @@
-// Copyright (c) 2014-2020 The Khronos Group Inc.

-//

-// Permission is hereby granted, free of charge, to any person obtaining a copy

-// of this software and/or associated documentation files (the "Materials"),

-// to deal in the Materials without restriction, including without limitation

-// the rights to use, copy, modify, merge, publish, distribute, sublicense,

-// and/or sell copies of the Materials, and to permit persons to whom the

-// Materials are furnished to do so, subject to the following conditions:

-//

-// The above copyright notice and this permission notice shall be included in

-// all copies or substantial portions of the Materials.

-//

-// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS

-// STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND

-// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/

-//

-// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

-// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

-// FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS

-// IN THE MATERIALS.

-

-// This header is automatically generated by the same tool that creates

-// the Binary Section of the SPIR-V specification.

-

-// Enumeration tokens for SPIR-V, in various styles:

-//   C, C++, C++11, JSON, Lua, Python, C#, D

-//

-// - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL

-// - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL

-// - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL

-// - Lua will use tables, e.g.: spv.SourceLanguage.GLSL

-// - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL']

-// - C# will use enum classes in the Specification class located in the "Spv" namespace,

-//     e.g.: Spv.Specification.SourceLanguage.GLSL

-// - D will have tokens under the "spv" module, e.g: spv.SourceLanguage.GLSL

-//

-// Some tokens act like mask values, which can be OR'd together,

-// while others are mutually exclusive.  The mask-like ones have

-// "Mask" in their name, and a parallel enum that has the shift

-// amount (1 << x) for each corresponding enumerant.

-

-#ifndef spirv_HPP

-#define spirv_HPP

-

-namespace spv {

-

-typedef unsigned int Id;

-

-#define SPV_VERSION 0x10600

-#define SPV_REVISION 1

-

-static const unsigned int MagicNumber = 0x07230203;

-static const unsigned int Version = 0x00010600;

-static const unsigned int Revision = 1;

-static const unsigned int OpCodeMask = 0xffff;

-static const unsigned int WordCountShift = 16;

-

-enum SourceLanguage {

-    SourceLanguageUnknown = 0,

-    SourceLanguageESSL = 1,

-    SourceLanguageGLSL = 2,

-    SourceLanguageOpenCL_C = 3,

-    SourceLanguageOpenCL_CPP = 4,

-    SourceLanguageHLSL = 5,

-    SourceLanguageCPP_for_OpenCL = 6,

-    SourceLanguageMax = 0x7fffffff,

-};

-

-enum ExecutionModel {

-    ExecutionModelVertex = 0,

-    ExecutionModelTessellationControl = 1,

-    ExecutionModelTessellationEvaluation = 2,

-    ExecutionModelGeometry = 3,

-    ExecutionModelFragment = 4,

-    ExecutionModelGLCompute = 5,

-    ExecutionModelKernel = 6,

-    ExecutionModelTaskNV = 5267,

-    ExecutionModelMeshNV = 5268,

-    ExecutionModelRayGenerationKHR = 5313,

-    ExecutionModelRayGenerationNV = 5313,

-    ExecutionModelIntersectionKHR = 5314,

-    ExecutionModelIntersectionNV = 5314,

-    ExecutionModelAnyHitKHR = 5315,

-    ExecutionModelAnyHitNV = 5315,

-    ExecutionModelClosestHitKHR = 5316,

-    ExecutionModelClosestHitNV = 5316,

-    ExecutionModelMissKHR = 5317,

-    ExecutionModelMissNV = 5317,

-    ExecutionModelCallableKHR = 5318,

-    ExecutionModelCallableNV = 5318,

-    ExecutionModelTaskEXT = 5364,

-    ExecutionModelMeshEXT = 5365,

-    ExecutionModelMax = 0x7fffffff,

-};

-

-enum AddressingModel {

-    AddressingModelLogical = 0,

-    AddressingModelPhysical32 = 1,

-    AddressingModelPhysical64 = 2,

-    AddressingModelPhysicalStorageBuffer64 = 5348,

-    AddressingModelPhysicalStorageBuffer64EXT = 5348,

-    AddressingModelMax = 0x7fffffff,

-};

-

-enum MemoryModel {

-    MemoryModelSimple = 0,

-    MemoryModelGLSL450 = 1,

-    MemoryModelOpenCL = 2,

-    MemoryModelVulkan = 3,

-    MemoryModelVulkanKHR = 3,

-    MemoryModelMax = 0x7fffffff,

-};

-

-enum ExecutionMode {

-    ExecutionModeInvocations = 0,

-    ExecutionModeSpacingEqual = 1,

-    ExecutionModeSpacingFractionalEven = 2,

-    ExecutionModeSpacingFractionalOdd = 3,

-    ExecutionModeVertexOrderCw = 4,

-    ExecutionModeVertexOrderCcw = 5,

-    ExecutionModePixelCenterInteger = 6,

-    ExecutionModeOriginUpperLeft = 7,

-    ExecutionModeOriginLowerLeft = 8,

-    ExecutionModeEarlyFragmentTests = 9,

-    ExecutionModePointMode = 10,

-    ExecutionModeXfb = 11,

-    ExecutionModeDepthReplacing = 12,

-    ExecutionModeDepthGreater = 14,

-    ExecutionModeDepthLess = 15,

-    ExecutionModeDepthUnchanged = 16,

-    ExecutionModeLocalSize = 17,

-    ExecutionModeLocalSizeHint = 18,

-    ExecutionModeInputPoints = 19,

-    ExecutionModeInputLines = 20,

-    ExecutionModeInputLinesAdjacency = 21,

-    ExecutionModeTriangles = 22,

-    ExecutionModeInputTrianglesAdjacency = 23,

-    ExecutionModeQuads = 24,

-    ExecutionModeIsolines = 25,

-    ExecutionModeOutputVertices = 26,

-    ExecutionModeOutputPoints = 27,

-    ExecutionModeOutputLineStrip = 28,

-    ExecutionModeOutputTriangleStrip = 29,

-    ExecutionModeVecTypeHint = 30,

-    ExecutionModeContractionOff = 31,

-    ExecutionModeInitializer = 33,

-    ExecutionModeFinalizer = 34,

-    ExecutionModeSubgroupSize = 35,

-    ExecutionModeSubgroupsPerWorkgroup = 36,

-    ExecutionModeSubgroupsPerWorkgroupId = 37,

-    ExecutionModeLocalSizeId = 38,

-    ExecutionModeLocalSizeHintId = 39,

-    ExecutionModeSubgroupUniformControlFlowKHR = 4421,

-    ExecutionModePostDepthCoverage = 4446,

-    ExecutionModeDenormPreserve = 4459,

-    ExecutionModeDenormFlushToZero = 4460,

-    ExecutionModeSignedZeroInfNanPreserve = 4461,

-    ExecutionModeRoundingModeRTE = 4462,

-    ExecutionModeRoundingModeRTZ = 4463,

-    ExecutionModeEarlyAndLateFragmentTestsAMD = 5017,

-    ExecutionModeStencilRefReplacingEXT = 5027,

-    ExecutionModeStencilRefUnchangedFrontAMD = 5079,

-    ExecutionModeStencilRefGreaterFrontAMD = 5080,

-    ExecutionModeStencilRefLessFrontAMD = 5081,

-    ExecutionModeStencilRefUnchangedBackAMD = 5082,

-    ExecutionModeStencilRefGreaterBackAMD = 5083,

-    ExecutionModeStencilRefLessBackAMD = 5084,

-    ExecutionModeOutputLinesEXT = 5269,

-    ExecutionModeOutputLinesNV = 5269,

-    ExecutionModeOutputPrimitivesEXT = 5270,

-    ExecutionModeOutputPrimitivesNV = 5270,

-    ExecutionModeDerivativeGroupQuadsNV = 5289,

-    ExecutionModeDerivativeGroupLinearNV = 5290,

-    ExecutionModeOutputTrianglesEXT = 5298,

-    ExecutionModeOutputTrianglesNV = 5298,

-    ExecutionModePixelInterlockOrderedEXT = 5366,

-    ExecutionModePixelInterlockUnorderedEXT = 5367,

-    ExecutionModeSampleInterlockOrderedEXT = 5368,

-    ExecutionModeSampleInterlockUnorderedEXT = 5369,

-    ExecutionModeShadingRateInterlockOrderedEXT = 5370,

-    ExecutionModeShadingRateInterlockUnorderedEXT = 5371,

-    ExecutionModeSharedLocalMemorySizeINTEL = 5618,

-    ExecutionModeRoundingModeRTPINTEL = 5620,

-    ExecutionModeRoundingModeRTNINTEL = 5621,

-    ExecutionModeFloatingPointModeALTINTEL = 5622,

-    ExecutionModeFloatingPointModeIEEEINTEL = 5623,

-    ExecutionModeMaxWorkgroupSizeINTEL = 5893,

-    ExecutionModeMaxWorkDimINTEL = 5894,

-    ExecutionModeNoGlobalOffsetINTEL = 5895,

-    ExecutionModeNumSIMDWorkitemsINTEL = 5896,

-    ExecutionModeSchedulerTargetFmaxMhzINTEL = 5903,

-    ExecutionModeMax = 0x7fffffff,

-};

-

-enum StorageClass {

-    StorageClassUniformConstant = 0,

-    StorageClassInput = 1,

-    StorageClassUniform = 2,

-    StorageClassOutput = 3,

-    StorageClassWorkgroup = 4,

-    StorageClassCrossWorkgroup = 5,

-    StorageClassPrivate = 6,

-    StorageClassFunction = 7,

-    StorageClassGeneric = 8,

-    StorageClassPushConstant = 9,

-    StorageClassAtomicCounter = 10,

-    StorageClassImage = 11,

-    StorageClassStorageBuffer = 12,

-    StorageClassCallableDataKHR = 5328,

-    StorageClassCallableDataNV = 5328,

-    StorageClassIncomingCallableDataKHR = 5329,

-    StorageClassIncomingCallableDataNV = 5329,

-    StorageClassRayPayloadKHR = 5338,

-    StorageClassRayPayloadNV = 5338,

-    StorageClassHitAttributeKHR = 5339,

-    StorageClassHitAttributeNV = 5339,

-    StorageClassIncomingRayPayloadKHR = 5342,

-    StorageClassIncomingRayPayloadNV = 5342,

-    StorageClassShaderRecordBufferKHR = 5343,

-    StorageClassShaderRecordBufferNV = 5343,

-    StorageClassPhysicalStorageBuffer = 5349,

-    StorageClassPhysicalStorageBufferEXT = 5349,

-    StorageClassTaskPayloadWorkgroupEXT = 5402,

-    StorageClassCodeSectionINTEL = 5605,

-    StorageClassDeviceOnlyINTEL = 5936,

-    StorageClassHostOnlyINTEL = 5937,

-    StorageClassMax = 0x7fffffff,

-};

-

-enum Dim {

-    Dim1D = 0,

-    Dim2D = 1,

-    Dim3D = 2,

-    DimCube = 3,

-    DimRect = 4,

-    DimBuffer = 5,

-    DimSubpassData = 6,

-    DimMax = 0x7fffffff,

-};

-

-enum SamplerAddressingMode {

-    SamplerAddressingModeNone = 0,

-    SamplerAddressingModeClampToEdge = 1,

-    SamplerAddressingModeClamp = 2,

-    SamplerAddressingModeRepeat = 3,

-    SamplerAddressingModeRepeatMirrored = 4,

-    SamplerAddressingModeMax = 0x7fffffff,

-};

-

-enum SamplerFilterMode {

-    SamplerFilterModeNearest = 0,

-    SamplerFilterModeLinear = 1,

-    SamplerFilterModeMax = 0x7fffffff,

-};

-

-enum ImageFormat {

-    ImageFormatUnknown = 0,

-    ImageFormatRgba32f = 1,

-    ImageFormatRgba16f = 2,

-    ImageFormatR32f = 3,

-    ImageFormatRgba8 = 4,

-    ImageFormatRgba8Snorm = 5,

-    ImageFormatRg32f = 6,

-    ImageFormatRg16f = 7,

-    ImageFormatR11fG11fB10f = 8,

-    ImageFormatR16f = 9,

-    ImageFormatRgba16 = 10,

-    ImageFormatRgb10A2 = 11,

-    ImageFormatRg16 = 12,

-    ImageFormatRg8 = 13,

-    ImageFormatR16 = 14,

-    ImageFormatR8 = 15,

-    ImageFormatRgba16Snorm = 16,

-    ImageFormatRg16Snorm = 17,

-    ImageFormatRg8Snorm = 18,

-    ImageFormatR16Snorm = 19,

-    ImageFormatR8Snorm = 20,

-    ImageFormatRgba32i = 21,

-    ImageFormatRgba16i = 22,

-    ImageFormatRgba8i = 23,

-    ImageFormatR32i = 24,

-    ImageFormatRg32i = 25,

-    ImageFormatRg16i = 26,

-    ImageFormatRg8i = 27,

-    ImageFormatR16i = 28,

-    ImageFormatR8i = 29,

-    ImageFormatRgba32ui = 30,

-    ImageFormatRgba16ui = 31,

-    ImageFormatRgba8ui = 32,

-    ImageFormatR32ui = 33,

-    ImageFormatRgb10a2ui = 34,

-    ImageFormatRg32ui = 35,

-    ImageFormatRg16ui = 36,

-    ImageFormatRg8ui = 37,

-    ImageFormatR16ui = 38,

-    ImageFormatR8ui = 39,

-    ImageFormatR64ui = 40,

-    ImageFormatR64i = 41,

-    ImageFormatMax = 0x7fffffff,

-};

-

-enum ImageChannelOrder {

-    ImageChannelOrderR = 0,

-    ImageChannelOrderA = 1,

-    ImageChannelOrderRG = 2,

-    ImageChannelOrderRA = 3,

-    ImageChannelOrderRGB = 4,

-    ImageChannelOrderRGBA = 5,

-    ImageChannelOrderBGRA = 6,

-    ImageChannelOrderARGB = 7,

-    ImageChannelOrderIntensity = 8,

-    ImageChannelOrderLuminance = 9,

-    ImageChannelOrderRx = 10,

-    ImageChannelOrderRGx = 11,

-    ImageChannelOrderRGBx = 12,

-    ImageChannelOrderDepth = 13,

-    ImageChannelOrderDepthStencil = 14,

-    ImageChannelOrdersRGB = 15,

-    ImageChannelOrdersRGBx = 16,

-    ImageChannelOrdersRGBA = 17,

-    ImageChannelOrdersBGRA = 18,

-    ImageChannelOrderABGR = 19,

-    ImageChannelOrderMax = 0x7fffffff,

-};

-

-enum ImageChannelDataType {

-    ImageChannelDataTypeSnormInt8 = 0,

-    ImageChannelDataTypeSnormInt16 = 1,

-    ImageChannelDataTypeUnormInt8 = 2,

-    ImageChannelDataTypeUnormInt16 = 3,

-    ImageChannelDataTypeUnormShort565 = 4,

-    ImageChannelDataTypeUnormShort555 = 5,

-    ImageChannelDataTypeUnormInt101010 = 6,

-    ImageChannelDataTypeSignedInt8 = 7,

-    ImageChannelDataTypeSignedInt16 = 8,

-    ImageChannelDataTypeSignedInt32 = 9,

-    ImageChannelDataTypeUnsignedInt8 = 10,

-    ImageChannelDataTypeUnsignedInt16 = 11,

-    ImageChannelDataTypeUnsignedInt32 = 12,

-    ImageChannelDataTypeHalfFloat = 13,

-    ImageChannelDataTypeFloat = 14,

-    ImageChannelDataTypeUnormInt24 = 15,

-    ImageChannelDataTypeUnormInt101010_2 = 16,

-    ImageChannelDataTypeMax = 0x7fffffff,

-};

-

-enum ImageOperandsShift {

-    ImageOperandsBiasShift = 0,

-    ImageOperandsLodShift = 1,

-    ImageOperandsGradShift = 2,

-    ImageOperandsConstOffsetShift = 3,

-    ImageOperandsOffsetShift = 4,

-    ImageOperandsConstOffsetsShift = 5,

-    ImageOperandsSampleShift = 6,

-    ImageOperandsMinLodShift = 7,

-    ImageOperandsMakeTexelAvailableShift = 8,

-    ImageOperandsMakeTexelAvailableKHRShift = 8,

-    ImageOperandsMakeTexelVisibleShift = 9,

-    ImageOperandsMakeTexelVisibleKHRShift = 9,

-    ImageOperandsNonPrivateTexelShift = 10,

-    ImageOperandsNonPrivateTexelKHRShift = 10,

-    ImageOperandsVolatileTexelShift = 11,

-    ImageOperandsVolatileTexelKHRShift = 11,

-    ImageOperandsSignExtendShift = 12,

-    ImageOperandsZeroExtendShift = 13,

-    ImageOperandsNontemporalShift = 14,

-    ImageOperandsOffsetsShift = 16,

-    ImageOperandsMax = 0x7fffffff,

-};

-

-enum ImageOperandsMask {

-    ImageOperandsMaskNone = 0,

-    ImageOperandsBiasMask = 0x00000001,

-    ImageOperandsLodMask = 0x00000002,

-    ImageOperandsGradMask = 0x00000004,

-    ImageOperandsConstOffsetMask = 0x00000008,

-    ImageOperandsOffsetMask = 0x00000010,

-    ImageOperandsConstOffsetsMask = 0x00000020,

-    ImageOperandsSampleMask = 0x00000040,

-    ImageOperandsMinLodMask = 0x00000080,

-    ImageOperandsMakeTexelAvailableMask = 0x00000100,

-    ImageOperandsMakeTexelAvailableKHRMask = 0x00000100,

-    ImageOperandsMakeTexelVisibleMask = 0x00000200,

-    ImageOperandsMakeTexelVisibleKHRMask = 0x00000200,

-    ImageOperandsNonPrivateTexelMask = 0x00000400,

-    ImageOperandsNonPrivateTexelKHRMask = 0x00000400,

-    ImageOperandsVolatileTexelMask = 0x00000800,

-    ImageOperandsVolatileTexelKHRMask = 0x00000800,

-    ImageOperandsSignExtendMask = 0x00001000,

-    ImageOperandsZeroExtendMask = 0x00002000,

-    ImageOperandsNontemporalMask = 0x00004000,

-    ImageOperandsOffsetsMask = 0x00010000,

-};

-

-enum FPFastMathModeShift {

-    FPFastMathModeNotNaNShift = 0,

-    FPFastMathModeNotInfShift = 1,

-    FPFastMathModeNSZShift = 2,

-    FPFastMathModeAllowRecipShift = 3,

-    FPFastMathModeFastShift = 4,

-    FPFastMathModeAllowContractFastINTELShift = 16,

-    FPFastMathModeAllowReassocINTELShift = 17,

-    FPFastMathModeMax = 0x7fffffff,

-};

-

-enum FPFastMathModeMask {

-    FPFastMathModeMaskNone = 0,

-    FPFastMathModeNotNaNMask = 0x00000001,

-    FPFastMathModeNotInfMask = 0x00000002,

-    FPFastMathModeNSZMask = 0x00000004,

-    FPFastMathModeAllowRecipMask = 0x00000008,

-    FPFastMathModeFastMask = 0x00000010,

-    FPFastMathModeAllowContractFastINTELMask = 0x00010000,

-    FPFastMathModeAllowReassocINTELMask = 0x00020000,

-};

-

-enum FPRoundingMode {

-    FPRoundingModeRTE = 0,

-    FPRoundingModeRTZ = 1,

-    FPRoundingModeRTP = 2,

-    FPRoundingModeRTN = 3,

-    FPRoundingModeMax = 0x7fffffff,

-};

-

-enum LinkageType {

-    LinkageTypeExport = 0,

-    LinkageTypeImport = 1,

-    LinkageTypeLinkOnceODR = 2,

-    LinkageTypeMax = 0x7fffffff,

-};

-

-enum AccessQualifier {

-    AccessQualifierReadOnly = 0,

-    AccessQualifierWriteOnly = 1,

-    AccessQualifierReadWrite = 2,

-    AccessQualifierMax = 0x7fffffff,

-};

-

-enum FunctionParameterAttribute {

-    FunctionParameterAttributeZext = 0,

-    FunctionParameterAttributeSext = 1,

-    FunctionParameterAttributeByVal = 2,

-    FunctionParameterAttributeSret = 3,

-    FunctionParameterAttributeNoAlias = 4,

-    FunctionParameterAttributeNoCapture = 5,

-    FunctionParameterAttributeNoWrite = 6,

-    FunctionParameterAttributeNoReadWrite = 7,

-    FunctionParameterAttributeMax = 0x7fffffff,

-};

-

-enum Decoration {

-    DecorationRelaxedPrecision = 0,

-    DecorationSpecId = 1,

-    DecorationBlock = 2,

-    DecorationBufferBlock = 3,

-    DecorationRowMajor = 4,

-    DecorationColMajor = 5,

-    DecorationArrayStride = 6,

-    DecorationMatrixStride = 7,

-    DecorationGLSLShared = 8,

-    DecorationGLSLPacked = 9,

-    DecorationCPacked = 10,

-    DecorationBuiltIn = 11,

-    DecorationNoPerspective = 13,

-    DecorationFlat = 14,

-    DecorationPatch = 15,

-    DecorationCentroid = 16,

-    DecorationSample = 17,

-    DecorationInvariant = 18,

-    DecorationRestrict = 19,

-    DecorationAliased = 20,

-    DecorationVolatile = 21,

-    DecorationConstant = 22,

-    DecorationCoherent = 23,

-    DecorationNonWritable = 24,

-    DecorationNonReadable = 25,

-    DecorationUniform = 26,

-    DecorationUniformId = 27,

-    DecorationSaturatedConversion = 28,

-    DecorationStream = 29,

-    DecorationLocation = 30,

-    DecorationComponent = 31,

-    DecorationIndex = 32,

-    DecorationBinding = 33,

-    DecorationDescriptorSet = 34,

-    DecorationOffset = 35,

-    DecorationXfbBuffer = 36,

-    DecorationXfbStride = 37,

-    DecorationFuncParamAttr = 38,

-    DecorationFPRoundingMode = 39,

-    DecorationFPFastMathMode = 40,

-    DecorationLinkageAttributes = 41,

-    DecorationNoContraction = 42,

-    DecorationInputAttachmentIndex = 43,

-    DecorationAlignment = 44,

-    DecorationMaxByteOffset = 45,

-    DecorationAlignmentId = 46,

-    DecorationMaxByteOffsetId = 47,

-    DecorationNoSignedWrap = 4469,

-    DecorationNoUnsignedWrap = 4470,

-    DecorationExplicitInterpAMD = 4999,

-    DecorationOverrideCoverageNV = 5248,

-    DecorationPassthroughNV = 5250,

-    DecorationViewportRelativeNV = 5252,

-    DecorationSecondaryViewportRelativeNV = 5256,

-    DecorationPerPrimitiveEXT = 5271,

-    DecorationPerPrimitiveNV = 5271,

-    DecorationPerViewNV = 5272,

-    DecorationPerTaskNV = 5273,

-    DecorationPerVertexKHR = 5285,

-    DecorationPerVertexNV = 5285,

-    DecorationNonUniform = 5300,

-    DecorationNonUniformEXT = 5300,

-    DecorationRestrictPointer = 5355,

-    DecorationRestrictPointerEXT = 5355,

-    DecorationAliasedPointer = 5356,

-    DecorationAliasedPointerEXT = 5356,

-    DecorationBindlessSamplerNV = 5398,

-    DecorationBindlessImageNV = 5399,

-    DecorationBoundSamplerNV = 5400,

-    DecorationBoundImageNV = 5401,

-    DecorationSIMTCallINTEL = 5599,

-    DecorationReferencedIndirectlyINTEL = 5602,

-    DecorationClobberINTEL = 5607,

-    DecorationSideEffectsINTEL = 5608,

-    DecorationVectorComputeVariableINTEL = 5624,

-    DecorationFuncParamIOKindINTEL = 5625,

-    DecorationVectorComputeFunctionINTEL = 5626,

-    DecorationStackCallINTEL = 5627,

-    DecorationGlobalVariableOffsetINTEL = 5628,

-    DecorationCounterBuffer = 5634,

-    DecorationHlslCounterBufferGOOGLE = 5634,

-    DecorationHlslSemanticGOOGLE = 5635,

-    DecorationUserSemantic = 5635,

-    DecorationUserTypeGOOGLE = 5636,

-    DecorationFunctionRoundingModeINTEL = 5822,

-    DecorationFunctionDenormModeINTEL = 5823,

-    DecorationRegisterINTEL = 5825,

-    DecorationMemoryINTEL = 5826,

-    DecorationNumbanksINTEL = 5827,

-    DecorationBankwidthINTEL = 5828,

-    DecorationMaxPrivateCopiesINTEL = 5829,

-    DecorationSinglepumpINTEL = 5830,

-    DecorationDoublepumpINTEL = 5831,

-    DecorationMaxReplicatesINTEL = 5832,

-    DecorationSimpleDualPortINTEL = 5833,

-    DecorationMergeINTEL = 5834,

-    DecorationBankBitsINTEL = 5835,

-    DecorationForcePow2DepthINTEL = 5836,

-    DecorationBurstCoalesceINTEL = 5899,

-    DecorationCacheSizeINTEL = 5900,

-    DecorationDontStaticallyCoalesceINTEL = 5901,

-    DecorationPrefetchINTEL = 5902,

-    DecorationStallEnableINTEL = 5905,

-    DecorationFuseLoopsInFunctionINTEL = 5907,

-    DecorationBufferLocationINTEL = 5921,

-    DecorationIOPipeStorageINTEL = 5944,

-    DecorationFunctionFloatingPointModeINTEL = 6080,

-    DecorationSingleElementVectorINTEL = 6085,

-    DecorationVectorComputeCallableFunctionINTEL = 6087,

-    DecorationMediaBlockIOINTEL = 6140,

-    DecorationMax = 0x7fffffff,

-};

-

-enum BuiltIn {

-    BuiltInPosition = 0,

-    BuiltInPointSize = 1,

-    BuiltInClipDistance = 3,

-    BuiltInCullDistance = 4,

-    BuiltInVertexId = 5,

-    BuiltInInstanceId = 6,

-    BuiltInPrimitiveId = 7,

-    BuiltInInvocationId = 8,

-    BuiltInLayer = 9,

-    BuiltInViewportIndex = 10,

-    BuiltInTessLevelOuter = 11,

-    BuiltInTessLevelInner = 12,

-    BuiltInTessCoord = 13,

-    BuiltInPatchVertices = 14,

-    BuiltInFragCoord = 15,

-    BuiltInPointCoord = 16,

-    BuiltInFrontFacing = 17,

-    BuiltInSampleId = 18,

-    BuiltInSamplePosition = 19,

-    BuiltInSampleMask = 20,

-    BuiltInFragDepth = 22,

-    BuiltInHelperInvocation = 23,

-    BuiltInNumWorkgroups = 24,

-    BuiltInWorkgroupSize = 25,

-    BuiltInWorkgroupId = 26,

-    BuiltInLocalInvocationId = 27,

-    BuiltInGlobalInvocationId = 28,

-    BuiltInLocalInvocationIndex = 29,

-    BuiltInWorkDim = 30,

-    BuiltInGlobalSize = 31,

-    BuiltInEnqueuedWorkgroupSize = 32,

-    BuiltInGlobalOffset = 33,

-    BuiltInGlobalLinearId = 34,

-    BuiltInSubgroupSize = 36,

-    BuiltInSubgroupMaxSize = 37,

-    BuiltInNumSubgroups = 38,

-    BuiltInNumEnqueuedSubgroups = 39,

-    BuiltInSubgroupId = 40,

-    BuiltInSubgroupLocalInvocationId = 41,

-    BuiltInVertexIndex = 42,

-    BuiltInInstanceIndex = 43,

-    BuiltInSubgroupEqMask = 4416,

-    BuiltInSubgroupEqMaskKHR = 4416,

-    BuiltInSubgroupGeMask = 4417,

-    BuiltInSubgroupGeMaskKHR = 4417,

-    BuiltInSubgroupGtMask = 4418,

-    BuiltInSubgroupGtMaskKHR = 4418,

-    BuiltInSubgroupLeMask = 4419,

-    BuiltInSubgroupLeMaskKHR = 4419,

-    BuiltInSubgroupLtMask = 4420,

-    BuiltInSubgroupLtMaskKHR = 4420,

-    BuiltInBaseVertex = 4424,

-    BuiltInBaseInstance = 4425,

-    BuiltInDrawIndex = 4426,

-    BuiltInPrimitiveShadingRateKHR = 4432,

-    BuiltInDeviceIndex = 4438,

-    BuiltInViewIndex = 4440,

-    BuiltInShadingRateKHR = 4444,

-    BuiltInBaryCoordNoPerspAMD = 4992,

-    BuiltInBaryCoordNoPerspCentroidAMD = 4993,

-    BuiltInBaryCoordNoPerspSampleAMD = 4994,

-    BuiltInBaryCoordSmoothAMD = 4995,

-    BuiltInBaryCoordSmoothCentroidAMD = 4996,

-    BuiltInBaryCoordSmoothSampleAMD = 4997,

-    BuiltInBaryCoordPullModelAMD = 4998,

-    BuiltInFragStencilRefEXT = 5014,

-    BuiltInViewportMaskNV = 5253,

-    BuiltInSecondaryPositionNV = 5257,

-    BuiltInSecondaryViewportMaskNV = 5258,

-    BuiltInPositionPerViewNV = 5261,

-    BuiltInViewportMaskPerViewNV = 5262,

-    BuiltInFullyCoveredEXT = 5264,

-    BuiltInTaskCountNV = 5274,

-    BuiltInPrimitiveCountNV = 5275,

-    BuiltInPrimitiveIndicesNV = 5276,

-    BuiltInClipDistancePerViewNV = 5277,

-    BuiltInCullDistancePerViewNV = 5278,

-    BuiltInLayerPerViewNV = 5279,

-    BuiltInMeshViewCountNV = 5280,

-    BuiltInMeshViewIndicesNV = 5281,

-    BuiltInBaryCoordKHR = 5286,

-    BuiltInBaryCoordNV = 5286,

-    BuiltInBaryCoordNoPerspKHR = 5287,

-    BuiltInBaryCoordNoPerspNV = 5287,

-    BuiltInFragSizeEXT = 5292,

-    BuiltInFragmentSizeNV = 5292,

-    BuiltInFragInvocationCountEXT = 5293,

-    BuiltInInvocationsPerPixelNV = 5293,

-    BuiltInPrimitivePointIndicesEXT = 5294,

-    BuiltInPrimitiveLineIndicesEXT = 5295,

-    BuiltInPrimitiveTriangleIndicesEXT = 5296,

-    BuiltInCullPrimitiveEXT = 5299,

-    BuiltInLaunchIdKHR = 5319,

-    BuiltInLaunchIdNV = 5319,

-    BuiltInLaunchSizeKHR = 5320,

-    BuiltInLaunchSizeNV = 5320,

-    BuiltInWorldRayOriginKHR = 5321,

-    BuiltInWorldRayOriginNV = 5321,

-    BuiltInWorldRayDirectionKHR = 5322,

-    BuiltInWorldRayDirectionNV = 5322,

-    BuiltInObjectRayOriginKHR = 5323,

-    BuiltInObjectRayOriginNV = 5323,

-    BuiltInObjectRayDirectionKHR = 5324,

-    BuiltInObjectRayDirectionNV = 5324,

-    BuiltInRayTminKHR = 5325,

-    BuiltInRayTminNV = 5325,

-    BuiltInRayTmaxKHR = 5326,

-    BuiltInRayTmaxNV = 5326,

-    BuiltInInstanceCustomIndexKHR = 5327,

-    BuiltInInstanceCustomIndexNV = 5327,

-    BuiltInObjectToWorldKHR = 5330,

-    BuiltInObjectToWorldNV = 5330,

-    BuiltInWorldToObjectKHR = 5331,

-    BuiltInWorldToObjectNV = 5331,

-    BuiltInHitTNV = 5332,

-    BuiltInHitKindKHR = 5333,

-    BuiltInHitKindNV = 5333,

-    BuiltInCurrentRayTimeNV = 5334,

-    BuiltInIncomingRayFlagsKHR = 5351,

-    BuiltInIncomingRayFlagsNV = 5351,

-    BuiltInRayGeometryIndexKHR = 5352,

-    BuiltInWarpsPerSMNV = 5374,

-    BuiltInSMCountNV = 5375,

-    BuiltInWarpIDNV = 5376,

-    BuiltInSMIDNV = 5377,

-    BuiltInCullMaskKHR = 6021,

-    BuiltInMax = 0x7fffffff,

-};

-

-enum SelectionControlShift {

-    SelectionControlFlattenShift = 0,

-    SelectionControlDontFlattenShift = 1,

-    SelectionControlMax = 0x7fffffff,

-};

-

-enum SelectionControlMask {

-    SelectionControlMaskNone = 0,

-    SelectionControlFlattenMask = 0x00000001,

-    SelectionControlDontFlattenMask = 0x00000002,

-};

-

-enum LoopControlShift {

-    LoopControlUnrollShift = 0,

-    LoopControlDontUnrollShift = 1,

-    LoopControlDependencyInfiniteShift = 2,

-    LoopControlDependencyLengthShift = 3,

-    LoopControlMinIterationsShift = 4,

-    LoopControlMaxIterationsShift = 5,

-    LoopControlIterationMultipleShift = 6,

-    LoopControlPeelCountShift = 7,

-    LoopControlPartialCountShift = 8,

-    LoopControlInitiationIntervalINTELShift = 16,

-    LoopControlMaxConcurrencyINTELShift = 17,

-    LoopControlDependencyArrayINTELShift = 18,

-    LoopControlPipelineEnableINTELShift = 19,

-    LoopControlLoopCoalesceINTELShift = 20,

-    LoopControlMaxInterleavingINTELShift = 21,

-    LoopControlSpeculatedIterationsINTELShift = 22,

-    LoopControlNoFusionINTELShift = 23,

-    LoopControlMax = 0x7fffffff,

-};

-

-enum LoopControlMask {

-    LoopControlMaskNone = 0,

-    LoopControlUnrollMask = 0x00000001,

-    LoopControlDontUnrollMask = 0x00000002,

-    LoopControlDependencyInfiniteMask = 0x00000004,

-    LoopControlDependencyLengthMask = 0x00000008,

-    LoopControlMinIterationsMask = 0x00000010,

-    LoopControlMaxIterationsMask = 0x00000020,

-    LoopControlIterationMultipleMask = 0x00000040,

-    LoopControlPeelCountMask = 0x00000080,

-    LoopControlPartialCountMask = 0x00000100,

-    LoopControlInitiationIntervalINTELMask = 0x00010000,

-    LoopControlMaxConcurrencyINTELMask = 0x00020000,

-    LoopControlDependencyArrayINTELMask = 0x00040000,

-    LoopControlPipelineEnableINTELMask = 0x00080000,

-    LoopControlLoopCoalesceINTELMask = 0x00100000,

-    LoopControlMaxInterleavingINTELMask = 0x00200000,

-    LoopControlSpeculatedIterationsINTELMask = 0x00400000,

-    LoopControlNoFusionINTELMask = 0x00800000,

-};

-

-enum FunctionControlShift {

-    FunctionControlInlineShift = 0,

-    FunctionControlDontInlineShift = 1,

-    FunctionControlPureShift = 2,

-    FunctionControlConstShift = 3,

-    FunctionControlOptNoneINTELShift = 16,

-    FunctionControlMax = 0x7fffffff,

-};

-

-enum FunctionControlMask {

-    FunctionControlMaskNone = 0,

-    FunctionControlInlineMask = 0x00000001,

-    FunctionControlDontInlineMask = 0x00000002,

-    FunctionControlPureMask = 0x00000004,

-    FunctionControlConstMask = 0x00000008,

-    FunctionControlOptNoneINTELMask = 0x00010000,

-};

-

-enum MemorySemanticsShift {

-    MemorySemanticsAcquireShift = 1,

-    MemorySemanticsReleaseShift = 2,

-    MemorySemanticsAcquireReleaseShift = 3,

-    MemorySemanticsSequentiallyConsistentShift = 4,

-    MemorySemanticsUniformMemoryShift = 6,

-    MemorySemanticsSubgroupMemoryShift = 7,

-    MemorySemanticsWorkgroupMemoryShift = 8,

-    MemorySemanticsCrossWorkgroupMemoryShift = 9,

-    MemorySemanticsAtomicCounterMemoryShift = 10,

-    MemorySemanticsImageMemoryShift = 11,

-    MemorySemanticsOutputMemoryShift = 12,

-    MemorySemanticsOutputMemoryKHRShift = 12,

-    MemorySemanticsMakeAvailableShift = 13,

-    MemorySemanticsMakeAvailableKHRShift = 13,

-    MemorySemanticsMakeVisibleShift = 14,

-    MemorySemanticsMakeVisibleKHRShift = 14,

-    MemorySemanticsVolatileShift = 15,

-    MemorySemanticsMax = 0x7fffffff,

-};

-

-enum MemorySemanticsMask {

-    MemorySemanticsMaskNone = 0,

-    MemorySemanticsAcquireMask = 0x00000002,

-    MemorySemanticsReleaseMask = 0x00000004,

-    MemorySemanticsAcquireReleaseMask = 0x00000008,

-    MemorySemanticsSequentiallyConsistentMask = 0x00000010,

-    MemorySemanticsUniformMemoryMask = 0x00000040,

-    MemorySemanticsSubgroupMemoryMask = 0x00000080,

-    MemorySemanticsWorkgroupMemoryMask = 0x00000100,

-    MemorySemanticsCrossWorkgroupMemoryMask = 0x00000200,

-    MemorySemanticsAtomicCounterMemoryMask = 0x00000400,

-    MemorySemanticsImageMemoryMask = 0x00000800,

-    MemorySemanticsOutputMemoryMask = 0x00001000,

-    MemorySemanticsOutputMemoryKHRMask = 0x00001000,

-    MemorySemanticsMakeAvailableMask = 0x00002000,

-    MemorySemanticsMakeAvailableKHRMask = 0x00002000,

-    MemorySemanticsMakeVisibleMask = 0x00004000,

-    MemorySemanticsMakeVisibleKHRMask = 0x00004000,

-    MemorySemanticsVolatileMask = 0x00008000,

-};

-

-enum MemoryAccessShift {

-    MemoryAccessVolatileShift = 0,

-    MemoryAccessAlignedShift = 1,

-    MemoryAccessNontemporalShift = 2,

-    MemoryAccessMakePointerAvailableShift = 3,

-    MemoryAccessMakePointerAvailableKHRShift = 3,

-    MemoryAccessMakePointerVisibleShift = 4,

-    MemoryAccessMakePointerVisibleKHRShift = 4,

-    MemoryAccessNonPrivatePointerShift = 5,

-    MemoryAccessNonPrivatePointerKHRShift = 5,

-    MemoryAccessMax = 0x7fffffff,

-};

-

-enum MemoryAccessMask {

-    MemoryAccessMaskNone = 0,

-    MemoryAccessVolatileMask = 0x00000001,

-    MemoryAccessAlignedMask = 0x00000002,

-    MemoryAccessNontemporalMask = 0x00000004,

-    MemoryAccessMakePointerAvailableMask = 0x00000008,

-    MemoryAccessMakePointerAvailableKHRMask = 0x00000008,

-    MemoryAccessMakePointerVisibleMask = 0x00000010,

-    MemoryAccessMakePointerVisibleKHRMask = 0x00000010,

-    MemoryAccessNonPrivatePointerMask = 0x00000020,

-    MemoryAccessNonPrivatePointerKHRMask = 0x00000020,

-};

-

-enum Scope {

-    ScopeCrossDevice = 0,

-    ScopeDevice = 1,

-    ScopeWorkgroup = 2,

-    ScopeSubgroup = 3,

-    ScopeInvocation = 4,

-    ScopeQueueFamily = 5,

-    ScopeQueueFamilyKHR = 5,

-    ScopeShaderCallKHR = 6,

-    ScopeMax = 0x7fffffff,

-};

-

-enum GroupOperation {

-    GroupOperationReduce = 0,

-    GroupOperationInclusiveScan = 1,

-    GroupOperationExclusiveScan = 2,

-    GroupOperationClusteredReduce = 3,

-    GroupOperationPartitionedReduceNV = 6,

-    GroupOperationPartitionedInclusiveScanNV = 7,

-    GroupOperationPartitionedExclusiveScanNV = 8,

-    GroupOperationMax = 0x7fffffff,

-};

-

-enum KernelEnqueueFlags {

-    KernelEnqueueFlagsNoWait = 0,

-    KernelEnqueueFlagsWaitKernel = 1,

-    KernelEnqueueFlagsWaitWorkGroup = 2,

-    KernelEnqueueFlagsMax = 0x7fffffff,

-};

-

-enum KernelProfilingInfoShift {

-    KernelProfilingInfoCmdExecTimeShift = 0,

-    KernelProfilingInfoMax = 0x7fffffff,

-};

-

-enum KernelProfilingInfoMask {

-    KernelProfilingInfoMaskNone = 0,

-    KernelProfilingInfoCmdExecTimeMask = 0x00000001,

-};

-

-enum Capability {

-    CapabilityMatrix = 0,

-    CapabilityShader = 1,

-    CapabilityGeometry = 2,

-    CapabilityTessellation = 3,

-    CapabilityAddresses = 4,

-    CapabilityLinkage = 5,

-    CapabilityKernel = 6,

-    CapabilityVector16 = 7,

-    CapabilityFloat16Buffer = 8,

-    CapabilityFloat16 = 9,

-    CapabilityFloat64 = 10,

-    CapabilityInt64 = 11,

-    CapabilityInt64Atomics = 12,

-    CapabilityImageBasic = 13,

-    CapabilityImageReadWrite = 14,

-    CapabilityImageMipmap = 15,

-    CapabilityPipes = 17,

-    CapabilityGroups = 18,

-    CapabilityDeviceEnqueue = 19,

-    CapabilityLiteralSampler = 20,

-    CapabilityAtomicStorage = 21,

-    CapabilityInt16 = 22,

-    CapabilityTessellationPointSize = 23,

-    CapabilityGeometryPointSize = 24,

-    CapabilityImageGatherExtended = 25,

-    CapabilityStorageImageMultisample = 27,

-    CapabilityUniformBufferArrayDynamicIndexing = 28,

-    CapabilitySampledImageArrayDynamicIndexing = 29,

-    CapabilityStorageBufferArrayDynamicIndexing = 30,

-    CapabilityStorageImageArrayDynamicIndexing = 31,

-    CapabilityClipDistance = 32,

-    CapabilityCullDistance = 33,

-    CapabilityImageCubeArray = 34,

-    CapabilitySampleRateShading = 35,

-    CapabilityImageRect = 36,

-    CapabilitySampledRect = 37,

-    CapabilityGenericPointer = 38,

-    CapabilityInt8 = 39,

-    CapabilityInputAttachment = 40,

-    CapabilitySparseResidency = 41,

-    CapabilityMinLod = 42,

-    CapabilitySampled1D = 43,

-    CapabilityImage1D = 44,

-    CapabilitySampledCubeArray = 45,

-    CapabilitySampledBuffer = 46,

-    CapabilityImageBuffer = 47,

-    CapabilityImageMSArray = 48,

-    CapabilityStorageImageExtendedFormats = 49,

-    CapabilityImageQuery = 50,

-    CapabilityDerivativeControl = 51,

-    CapabilityInterpolationFunction = 52,

-    CapabilityTransformFeedback = 53,

-    CapabilityGeometryStreams = 54,

-    CapabilityStorageImageReadWithoutFormat = 55,

-    CapabilityStorageImageWriteWithoutFormat = 56,

-    CapabilityMultiViewport = 57,

-    CapabilitySubgroupDispatch = 58,

-    CapabilityNamedBarrier = 59,

-    CapabilityPipeStorage = 60,

-    CapabilityGroupNonUniform = 61,

-    CapabilityGroupNonUniformVote = 62,

-    CapabilityGroupNonUniformArithmetic = 63,

-    CapabilityGroupNonUniformBallot = 64,

-    CapabilityGroupNonUniformShuffle = 65,

-    CapabilityGroupNonUniformShuffleRelative = 66,

-    CapabilityGroupNonUniformClustered = 67,

-    CapabilityGroupNonUniformQuad = 68,

-    CapabilityShaderLayer = 69,

-    CapabilityShaderViewportIndex = 70,

-    CapabilityUniformDecoration = 71,

-    CapabilityFragmentShadingRateKHR = 4422,

-    CapabilitySubgroupBallotKHR = 4423,

-    CapabilityDrawParameters = 4427,

-    CapabilityWorkgroupMemoryExplicitLayoutKHR = 4428,

-    CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR = 4429,

-    CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR = 4430,

-    CapabilitySubgroupVoteKHR = 4431,

-    CapabilityStorageBuffer16BitAccess = 4433,

-    CapabilityStorageUniformBufferBlock16 = 4433,

-    CapabilityStorageUniform16 = 4434,

-    CapabilityUniformAndStorageBuffer16BitAccess = 4434,

-    CapabilityStoragePushConstant16 = 4435,

-    CapabilityStorageInputOutput16 = 4436,

-    CapabilityDeviceGroup = 4437,

-    CapabilityMultiView = 4439,

-    CapabilityVariablePointersStorageBuffer = 4441,

-    CapabilityVariablePointers = 4442,

-    CapabilityAtomicStorageOps = 4445,

-    CapabilitySampleMaskPostDepthCoverage = 4447,

-    CapabilityStorageBuffer8BitAccess = 4448,

-    CapabilityUniformAndStorageBuffer8BitAccess = 4449,

-    CapabilityStoragePushConstant8 = 4450,

-    CapabilityDenormPreserve = 4464,

-    CapabilityDenormFlushToZero = 4465,

-    CapabilitySignedZeroInfNanPreserve = 4466,

-    CapabilityRoundingModeRTE = 4467,

-    CapabilityRoundingModeRTZ = 4468,

-    CapabilityRayQueryProvisionalKHR = 4471,

-    CapabilityRayQueryKHR = 4472,

-    CapabilityRayTraversalPrimitiveCullingKHR = 4478,

-    CapabilityRayTracingKHR = 4479,

-    CapabilityFloat16ImageAMD = 5008,

-    CapabilityImageGatherBiasLodAMD = 5009,

-    CapabilityFragmentMaskAMD = 5010,

-    CapabilityStencilExportEXT = 5013,

-    CapabilityImageReadWriteLodAMD = 5015,

-    CapabilityInt64ImageEXT = 5016,

-    CapabilityShaderClockKHR = 5055,

-    CapabilitySampleMaskOverrideCoverageNV = 5249,

-    CapabilityGeometryShaderPassthroughNV = 5251,

-    CapabilityShaderViewportIndexLayerEXT = 5254,

-    CapabilityShaderViewportIndexLayerNV = 5254,

-    CapabilityShaderViewportMaskNV = 5255,

-    CapabilityShaderStereoViewNV = 5259,

-    CapabilityPerViewAttributesNV = 5260,

-    CapabilityFragmentFullyCoveredEXT = 5265,

-    CapabilityMeshShadingNV = 5266,

-    CapabilityImageFootprintNV = 5282,

-    CapabilityMeshShadingEXT = 5283,

-	CapabilityFragmentBarycentricKHR = 5284,

-    CapabilityFragmentBarycentricNV = 5284,

-    CapabilityComputeDerivativeGroupQuadsNV = 5288,

-    CapabilityFragmentDensityEXT = 5291,

-    CapabilityShadingRateNV = 5291,

-    CapabilityGroupNonUniformPartitionedNV = 5297,

-    CapabilityShaderNonUniform = 5301,

-    CapabilityShaderNonUniformEXT = 5301,

-    CapabilityRuntimeDescriptorArray = 5302,

-    CapabilityRuntimeDescriptorArrayEXT = 5302,

-    CapabilityInputAttachmentArrayDynamicIndexing = 5303,

-    CapabilityInputAttachmentArrayDynamicIndexingEXT = 5303,

-    CapabilityUniformTexelBufferArrayDynamicIndexing = 5304,

-    CapabilityUniformTexelBufferArrayDynamicIndexingEXT = 5304,

-    CapabilityStorageTexelBufferArrayDynamicIndexing = 5305,

-    CapabilityStorageTexelBufferArrayDynamicIndexingEXT = 5305,

-    CapabilityUniformBufferArrayNonUniformIndexing = 5306,

-    CapabilityUniformBufferArrayNonUniformIndexingEXT = 5306,

-    CapabilitySampledImageArrayNonUniformIndexing = 5307,

-    CapabilitySampledImageArrayNonUniformIndexingEXT = 5307,

-    CapabilityStorageBufferArrayNonUniformIndexing = 5308,

-    CapabilityStorageBufferArrayNonUniformIndexingEXT = 5308,

-    CapabilityStorageImageArrayNonUniformIndexing = 5309,

-    CapabilityStorageImageArrayNonUniformIndexingEXT = 5309,

-    CapabilityInputAttachmentArrayNonUniformIndexing = 5310,

-    CapabilityInputAttachmentArrayNonUniformIndexingEXT = 5310,

-    CapabilityUniformTexelBufferArrayNonUniformIndexing = 5311,

-    CapabilityUniformTexelBufferArrayNonUniformIndexingEXT = 5311,

-    CapabilityStorageTexelBufferArrayNonUniformIndexing = 5312,

-    CapabilityStorageTexelBufferArrayNonUniformIndexingEXT = 5312,

-    CapabilityRayTracingNV = 5340,

-    CapabilityRayTracingMotionBlurNV = 5341,

-    CapabilityVulkanMemoryModel = 5345,

-    CapabilityVulkanMemoryModelKHR = 5345,

-    CapabilityVulkanMemoryModelDeviceScope = 5346,

-    CapabilityVulkanMemoryModelDeviceScopeKHR = 5346,

-    CapabilityPhysicalStorageBufferAddresses = 5347,

-    CapabilityPhysicalStorageBufferAddressesEXT = 5347,

-    CapabilityComputeDerivativeGroupLinearNV = 5350,

-    CapabilityRayTracingProvisionalKHR = 5353,

-    CapabilityCooperativeMatrixNV = 5357,

-    CapabilityFragmentShaderSampleInterlockEXT = 5363,

-    CapabilityFragmentShaderShadingRateInterlockEXT = 5372,

-    CapabilityShaderSMBuiltinsNV = 5373,

-    CapabilityFragmentShaderPixelInterlockEXT = 5378,

-    CapabilityDemoteToHelperInvocation = 5379,

-    CapabilityDemoteToHelperInvocationEXT = 5379,

-    CapabilityBindlessTextureNV = 5390,

-    CapabilitySubgroupShuffleINTEL = 5568,

-    CapabilitySubgroupBufferBlockIOINTEL = 5569,

-    CapabilitySubgroupImageBlockIOINTEL = 5570,

-    CapabilitySubgroupImageMediaBlockIOINTEL = 5579,

-    CapabilityRoundToInfinityINTEL = 5582,

-    CapabilityFloatingPointModeINTEL = 5583,

-    CapabilityIntegerFunctions2INTEL = 5584,

-    CapabilityFunctionPointersINTEL = 5603,

-    CapabilityIndirectReferencesINTEL = 5604,

-    CapabilityAsmINTEL = 5606,

-    CapabilityAtomicFloat32MinMaxEXT = 5612,

-    CapabilityAtomicFloat64MinMaxEXT = 5613,

-    CapabilityAtomicFloat16MinMaxEXT = 5616,

-    CapabilityVectorComputeINTEL = 5617,

-    CapabilityVectorAnyINTEL = 5619,

-    CapabilityExpectAssumeKHR = 5629,

-    CapabilitySubgroupAvcMotionEstimationINTEL = 5696,

-    CapabilitySubgroupAvcMotionEstimationIntraINTEL = 5697,

-    CapabilitySubgroupAvcMotionEstimationChromaINTEL = 5698,

-    CapabilityVariableLengthArrayINTEL = 5817,

-    CapabilityFunctionFloatControlINTEL = 5821,

-    CapabilityFPGAMemoryAttributesINTEL = 5824,

-    CapabilityFPFastMathModeINTEL = 5837,

-    CapabilityArbitraryPrecisionIntegersINTEL = 5844,

-    CapabilityArbitraryPrecisionFloatingPointINTEL = 5845,

-    CapabilityUnstructuredLoopControlsINTEL = 5886,

-    CapabilityFPGALoopControlsINTEL = 5888,

-    CapabilityKernelAttributesINTEL = 5892,

-    CapabilityFPGAKernelAttributesINTEL = 5897,

-    CapabilityFPGAMemoryAccessesINTEL = 5898,

-    CapabilityFPGAClusterAttributesINTEL = 5904,

-    CapabilityLoopFuseINTEL = 5906,

-    CapabilityFPGABufferLocationINTEL = 5920,

-    CapabilityArbitraryPrecisionFixedPointINTEL = 5922,

-    CapabilityUSMStorageClassesINTEL = 5935,

-    CapabilityIOPipesINTEL = 5943,

-    CapabilityBlockingPipesINTEL = 5945,

-    CapabilityFPGARegINTEL = 5948,

-    CapabilityDotProductInputAll = 6016,

-    CapabilityDotProductInputAllKHR = 6016,

-    CapabilityDotProductInput4x8Bit = 6017,

-    CapabilityDotProductInput4x8BitKHR = 6017,

-    CapabilityDotProductInput4x8BitPacked = 6018,

-    CapabilityDotProductInput4x8BitPackedKHR = 6018,

-    CapabilityDotProduct = 6019,

-    CapabilityDotProductKHR = 6019,

-    CapabilityRayCullMaskKHR = 6020,

-    CapabilityBitInstructions = 6025,

-    CapabilityAtomicFloat32AddEXT = 6033,

-    CapabilityAtomicFloat64AddEXT = 6034,

-    CapabilityLongConstantCompositeINTEL = 6089,

-    CapabilityOptNoneINTEL = 6094,

-    CapabilityAtomicFloat16AddEXT = 6095,

-    CapabilityDebugInfoModuleINTEL = 6114,

-    CapabilityMax = 0x7fffffff,

-};

-

-enum RayFlagsShift {

-    RayFlagsOpaqueKHRShift = 0,

-    RayFlagsNoOpaqueKHRShift = 1,

-    RayFlagsTerminateOnFirstHitKHRShift = 2,

-    RayFlagsSkipClosestHitShaderKHRShift = 3,

-    RayFlagsCullBackFacingTrianglesKHRShift = 4,

-    RayFlagsCullFrontFacingTrianglesKHRShift = 5,

-    RayFlagsCullOpaqueKHRShift = 6,

-    RayFlagsCullNoOpaqueKHRShift = 7,

-    RayFlagsSkipTrianglesKHRShift = 8,

-    RayFlagsSkipAABBsKHRShift = 9,

-    RayFlagsMax = 0x7fffffff,

-};

-

-enum RayFlagsMask {

-    RayFlagsMaskNone = 0,

-    RayFlagsOpaqueKHRMask = 0x00000001,

-    RayFlagsNoOpaqueKHRMask = 0x00000002,

-    RayFlagsTerminateOnFirstHitKHRMask = 0x00000004,

-    RayFlagsSkipClosestHitShaderKHRMask = 0x00000008,

-    RayFlagsCullBackFacingTrianglesKHRMask = 0x00000010,

-    RayFlagsCullFrontFacingTrianglesKHRMask = 0x00000020,

-    RayFlagsCullOpaqueKHRMask = 0x00000040,

-    RayFlagsCullNoOpaqueKHRMask = 0x00000080,

-    RayFlagsSkipTrianglesKHRMask = 0x00000100,

-    RayFlagsSkipAABBsKHRMask = 0x00000200,

-};

-

-enum RayQueryIntersection {

-    RayQueryIntersectionRayQueryCandidateIntersectionKHR = 0,

-    RayQueryIntersectionRayQueryCommittedIntersectionKHR = 1,

-    RayQueryIntersectionMax = 0x7fffffff,

-};

-

-enum RayQueryCommittedIntersectionType {

-    RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR = 0,

-    RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR = 1,

-    RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR = 2,

-    RayQueryCommittedIntersectionTypeMax = 0x7fffffff,

-};

-

-enum RayQueryCandidateIntersectionType {

-    RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR = 0,

-    RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR = 1,

-    RayQueryCandidateIntersectionTypeMax = 0x7fffffff,

-};

-

-enum FragmentShadingRateShift {

-    FragmentShadingRateVertical2PixelsShift = 0,

-    FragmentShadingRateVertical4PixelsShift = 1,

-    FragmentShadingRateHorizontal2PixelsShift = 2,

-    FragmentShadingRateHorizontal4PixelsShift = 3,

-    FragmentShadingRateMax = 0x7fffffff,

-};

-

-enum FragmentShadingRateMask {

-    FragmentShadingRateMaskNone = 0,

-    FragmentShadingRateVertical2PixelsMask = 0x00000001,

-    FragmentShadingRateVertical4PixelsMask = 0x00000002,

-    FragmentShadingRateHorizontal2PixelsMask = 0x00000004,

-    FragmentShadingRateHorizontal4PixelsMask = 0x00000008,

-};

-

-enum FPDenormMode {

-    FPDenormModePreserve = 0,

-    FPDenormModeFlushToZero = 1,

-    FPDenormModeMax = 0x7fffffff,

-};

-

-enum FPOperationMode {

-    FPOperationModeIEEE = 0,

-    FPOperationModeALT = 1,

-    FPOperationModeMax = 0x7fffffff,

-};

-

-enum QuantizationModes {

-    QuantizationModesTRN = 0,

-    QuantizationModesTRN_ZERO = 1,

-    QuantizationModesRND = 2,

-    QuantizationModesRND_ZERO = 3,

-    QuantizationModesRND_INF = 4,

-    QuantizationModesRND_MIN_INF = 5,

-    QuantizationModesRND_CONV = 6,

-    QuantizationModesRND_CONV_ODD = 7,

-    QuantizationModesMax = 0x7fffffff,

-};

-

-enum OverflowModes {

-    OverflowModesWRAP = 0,

-    OverflowModesSAT = 1,

-    OverflowModesSAT_ZERO = 2,

-    OverflowModesSAT_SYM = 3,

-    OverflowModesMax = 0x7fffffff,

-};

-

-enum PackedVectorFormat {

-    PackedVectorFormatPackedVectorFormat4x8Bit = 0,

-    PackedVectorFormatPackedVectorFormat4x8BitKHR = 0,

-    PackedVectorFormatMax = 0x7fffffff,

-};

-

-enum Op {

-    OpNop = 0,

-    OpUndef = 1,

-    OpSourceContinued = 2,

-    OpSource = 3,

-    OpSourceExtension = 4,

-    OpName = 5,

-    OpMemberName = 6,

-    OpString = 7,

-    OpLine = 8,

-    OpExtension = 10,

-    OpExtInstImport = 11,

-    OpExtInst = 12,

-    OpMemoryModel = 14,

-    OpEntryPoint = 15,

-    OpExecutionMode = 16,

-    OpCapability = 17,

-    OpTypeVoid = 19,

-    OpTypeBool = 20,

-    OpTypeInt = 21,

-    OpTypeFloat = 22,

-    OpTypeVector = 23,

-    OpTypeMatrix = 24,

-    OpTypeImage = 25,

-    OpTypeSampler = 26,

-    OpTypeSampledImage = 27,

-    OpTypeArray = 28,

-    OpTypeRuntimeArray = 29,

-    OpTypeStruct = 30,

-    OpTypeOpaque = 31,

-    OpTypePointer = 32,

-    OpTypeFunction = 33,

-    OpTypeEvent = 34,

-    OpTypeDeviceEvent = 35,

-    OpTypeReserveId = 36,

-    OpTypeQueue = 37,

-    OpTypePipe = 38,

-    OpTypeForwardPointer = 39,

-    OpConstantTrue = 41,

-    OpConstantFalse = 42,

-    OpConstant = 43,

-    OpConstantComposite = 44,

-    OpConstantSampler = 45,

-    OpConstantNull = 46,

-    OpSpecConstantTrue = 48,

-    OpSpecConstantFalse = 49,

-    OpSpecConstant = 50,

-    OpSpecConstantComposite = 51,

-    OpSpecConstantOp = 52,

-    OpFunction = 54,

-    OpFunctionParameter = 55,

-    OpFunctionEnd = 56,

-    OpFunctionCall = 57,

-    OpVariable = 59,

-    OpImageTexelPointer = 60,

-    OpLoad = 61,

-    OpStore = 62,

-    OpCopyMemory = 63,

-    OpCopyMemorySized = 64,

-    OpAccessChain = 65,

-    OpInBoundsAccessChain = 66,

-    OpPtrAccessChain = 67,

-    OpArrayLength = 68,

-    OpGenericPtrMemSemantics = 69,

-    OpInBoundsPtrAccessChain = 70,

-    OpDecorate = 71,

-    OpMemberDecorate = 72,

-    OpDecorationGroup = 73,

-    OpGroupDecorate = 74,

-    OpGroupMemberDecorate = 75,

-    OpVectorExtractDynamic = 77,

-    OpVectorInsertDynamic = 78,

-    OpVectorShuffle = 79,

-    OpCompositeConstruct = 80,

-    OpCompositeExtract = 81,

-    OpCompositeInsert = 82,

-    OpCopyObject = 83,

-    OpTranspose = 84,

-    OpSampledImage = 86,

-    OpImageSampleImplicitLod = 87,

-    OpImageSampleExplicitLod = 88,

-    OpImageSampleDrefImplicitLod = 89,

-    OpImageSampleDrefExplicitLod = 90,

-    OpImageSampleProjImplicitLod = 91,

-    OpImageSampleProjExplicitLod = 92,

-    OpImageSampleProjDrefImplicitLod = 93,

-    OpImageSampleProjDrefExplicitLod = 94,

-    OpImageFetch = 95,

-    OpImageGather = 96,

-    OpImageDrefGather = 97,

-    OpImageRead = 98,

-    OpImageWrite = 99,

-    OpImage = 100,

-    OpImageQueryFormat = 101,

-    OpImageQueryOrder = 102,

-    OpImageQuerySizeLod = 103,

-    OpImageQuerySize = 104,

-    OpImageQueryLod = 105,

-    OpImageQueryLevels = 106,

-    OpImageQuerySamples = 107,

-    OpConvertFToU = 109,

-    OpConvertFToS = 110,

-    OpConvertSToF = 111,

-    OpConvertUToF = 112,

-    OpUConvert = 113,

-    OpSConvert = 114,

-    OpFConvert = 115,

-    OpQuantizeToF16 = 116,

-    OpConvertPtrToU = 117,

-    OpSatConvertSToU = 118,

-    OpSatConvertUToS = 119,

-    OpConvertUToPtr = 120,

-    OpPtrCastToGeneric = 121,

-    OpGenericCastToPtr = 122,

-    OpGenericCastToPtrExplicit = 123,

-    OpBitcast = 124,

-    OpSNegate = 126,

-    OpFNegate = 127,

-    OpIAdd = 128,

-    OpFAdd = 129,

-    OpISub = 130,

-    OpFSub = 131,

-    OpIMul = 132,

-    OpFMul = 133,

-    OpUDiv = 134,

-    OpSDiv = 135,

-    OpFDiv = 136,

-    OpUMod = 137,

-    OpSRem = 138,

-    OpSMod = 139,

-    OpFRem = 140,

-    OpFMod = 141,

-    OpVectorTimesScalar = 142,

-    OpMatrixTimesScalar = 143,

-    OpVectorTimesMatrix = 144,

-    OpMatrixTimesVector = 145,

-    OpMatrixTimesMatrix = 146,

-    OpOuterProduct = 147,

-    OpDot = 148,

-    OpIAddCarry = 149,

-    OpISubBorrow = 150,

-    OpUMulExtended = 151,

-    OpSMulExtended = 152,

-    OpAny = 154,

-    OpAll = 155,

-    OpIsNan = 156,

-    OpIsInf = 157,

-    OpIsFinite = 158,

-    OpIsNormal = 159,

-    OpSignBitSet = 160,

-    OpLessOrGreater = 161,

-    OpOrdered = 162,

-    OpUnordered = 163,

-    OpLogicalEqual = 164,

-    OpLogicalNotEqual = 165,

-    OpLogicalOr = 166,

-    OpLogicalAnd = 167,

-    OpLogicalNot = 168,

-    OpSelect = 169,

-    OpIEqual = 170,

-    OpINotEqual = 171,

-    OpUGreaterThan = 172,

-    OpSGreaterThan = 173,

-    OpUGreaterThanEqual = 174,

-    OpSGreaterThanEqual = 175,

-    OpULessThan = 176,

-    OpSLessThan = 177,

-    OpULessThanEqual = 178,

-    OpSLessThanEqual = 179,

-    OpFOrdEqual = 180,

-    OpFUnordEqual = 181,

-    OpFOrdNotEqual = 182,

-    OpFUnordNotEqual = 183,

-    OpFOrdLessThan = 184,

-    OpFUnordLessThan = 185,

-    OpFOrdGreaterThan = 186,

-    OpFUnordGreaterThan = 187,

-    OpFOrdLessThanEqual = 188,

-    OpFUnordLessThanEqual = 189,

-    OpFOrdGreaterThanEqual = 190,

-    OpFUnordGreaterThanEqual = 191,

-    OpShiftRightLogical = 194,

-    OpShiftRightArithmetic = 195,

-    OpShiftLeftLogical = 196,

-    OpBitwiseOr = 197,

-    OpBitwiseXor = 198,

-    OpBitwiseAnd = 199,

-    OpNot = 200,

-    OpBitFieldInsert = 201,

-    OpBitFieldSExtract = 202,

-    OpBitFieldUExtract = 203,

-    OpBitReverse = 204,

-    OpBitCount = 205,

-    OpDPdx = 207,

-    OpDPdy = 208,

-    OpFwidth = 209,

-    OpDPdxFine = 210,

-    OpDPdyFine = 211,

-    OpFwidthFine = 212,

-    OpDPdxCoarse = 213,

-    OpDPdyCoarse = 214,

-    OpFwidthCoarse = 215,

-    OpEmitVertex = 218,

-    OpEndPrimitive = 219,

-    OpEmitStreamVertex = 220,

-    OpEndStreamPrimitive = 221,

-    OpControlBarrier = 224,

-    OpMemoryBarrier = 225,

-    OpAtomicLoad = 227,

-    OpAtomicStore = 228,

-    OpAtomicExchange = 229,

-    OpAtomicCompareExchange = 230,

-    OpAtomicCompareExchangeWeak = 231,

-    OpAtomicIIncrement = 232,

-    OpAtomicIDecrement = 233,

-    OpAtomicIAdd = 234,

-    OpAtomicISub = 235,

-    OpAtomicSMin = 236,

-    OpAtomicUMin = 237,

-    OpAtomicSMax = 238,

-    OpAtomicUMax = 239,

-    OpAtomicAnd = 240,

-    OpAtomicOr = 241,

-    OpAtomicXor = 242,

-    OpPhi = 245,

-    OpLoopMerge = 246,

-    OpSelectionMerge = 247,

-    OpLabel = 248,

-    OpBranch = 249,

-    OpBranchConditional = 250,

-    OpSwitch = 251,

-    OpKill = 252,

-    OpReturn = 253,

-    OpReturnValue = 254,

-    OpUnreachable = 255,

-    OpLifetimeStart = 256,

-    OpLifetimeStop = 257,

-    OpGroupAsyncCopy = 259,

-    OpGroupWaitEvents = 260,

-    OpGroupAll = 261,

-    OpGroupAny = 262,

-    OpGroupBroadcast = 263,

-    OpGroupIAdd = 264,

-    OpGroupFAdd = 265,

-    OpGroupFMin = 266,

-    OpGroupUMin = 267,

-    OpGroupSMin = 268,

-    OpGroupFMax = 269,

-    OpGroupUMax = 270,

-    OpGroupSMax = 271,

-    OpReadPipe = 274,

-    OpWritePipe = 275,

-    OpReservedReadPipe = 276,

-    OpReservedWritePipe = 277,

-    OpReserveReadPipePackets = 278,

-    OpReserveWritePipePackets = 279,

-    OpCommitReadPipe = 280,

-    OpCommitWritePipe = 281,

-    OpIsValidReserveId = 282,

-    OpGetNumPipePackets = 283,

-    OpGetMaxPipePackets = 284,

-    OpGroupReserveReadPipePackets = 285,

-    OpGroupReserveWritePipePackets = 286,

-    OpGroupCommitReadPipe = 287,

-    OpGroupCommitWritePipe = 288,

-    OpEnqueueMarker = 291,

-    OpEnqueueKernel = 292,

-    OpGetKernelNDrangeSubGroupCount = 293,

-    OpGetKernelNDrangeMaxSubGroupSize = 294,

-    OpGetKernelWorkGroupSize = 295,

-    OpGetKernelPreferredWorkGroupSizeMultiple = 296,

-    OpRetainEvent = 297,

-    OpReleaseEvent = 298,

-    OpCreateUserEvent = 299,

-    OpIsValidEvent = 300,

-    OpSetUserEventStatus = 301,

-    OpCaptureEventProfilingInfo = 302,

-    OpGetDefaultQueue = 303,

-    OpBuildNDRange = 304,

-    OpImageSparseSampleImplicitLod = 305,

-    OpImageSparseSampleExplicitLod = 306,

-    OpImageSparseSampleDrefImplicitLod = 307,

-    OpImageSparseSampleDrefExplicitLod = 308,

-    OpImageSparseSampleProjImplicitLod = 309,

-    OpImageSparseSampleProjExplicitLod = 310,

-    OpImageSparseSampleProjDrefImplicitLod = 311,

-    OpImageSparseSampleProjDrefExplicitLod = 312,

-    OpImageSparseFetch = 313,

-    OpImageSparseGather = 314,

-    OpImageSparseDrefGather = 315,

-    OpImageSparseTexelsResident = 316,

-    OpNoLine = 317,

-    OpAtomicFlagTestAndSet = 318,

-    OpAtomicFlagClear = 319,

-    OpImageSparseRead = 320,

-    OpSizeOf = 321,

-    OpTypePipeStorage = 322,

-    OpConstantPipeStorage = 323,

-    OpCreatePipeFromPipeStorage = 324,

-    OpGetKernelLocalSizeForSubgroupCount = 325,

-    OpGetKernelMaxNumSubgroups = 326,

-    OpTypeNamedBarrier = 327,

-    OpNamedBarrierInitialize = 328,

-    OpMemoryNamedBarrier = 329,

-    OpModuleProcessed = 330,

-    OpExecutionModeId = 331,

-    OpDecorateId = 332,

-    OpGroupNonUniformElect = 333,

-    OpGroupNonUniformAll = 334,

-    OpGroupNonUniformAny = 335,

-    OpGroupNonUniformAllEqual = 336,

-    OpGroupNonUniformBroadcast = 337,

-    OpGroupNonUniformBroadcastFirst = 338,

-    OpGroupNonUniformBallot = 339,

-    OpGroupNonUniformInverseBallot = 340,

-    OpGroupNonUniformBallotBitExtract = 341,

-    OpGroupNonUniformBallotBitCount = 342,

-    OpGroupNonUniformBallotFindLSB = 343,

-    OpGroupNonUniformBallotFindMSB = 344,

-    OpGroupNonUniformShuffle = 345,

-    OpGroupNonUniformShuffleXor = 346,

-    OpGroupNonUniformShuffleUp = 347,

-    OpGroupNonUniformShuffleDown = 348,

-    OpGroupNonUniformIAdd = 349,

-    OpGroupNonUniformFAdd = 350,

-    OpGroupNonUniformIMul = 351,

-    OpGroupNonUniformFMul = 352,

-    OpGroupNonUniformSMin = 353,

-    OpGroupNonUniformUMin = 354,

-    OpGroupNonUniformFMin = 355,

-    OpGroupNonUniformSMax = 356,

-    OpGroupNonUniformUMax = 357,

-    OpGroupNonUniformFMax = 358,

-    OpGroupNonUniformBitwiseAnd = 359,

-    OpGroupNonUniformBitwiseOr = 360,

-    OpGroupNonUniformBitwiseXor = 361,

-    OpGroupNonUniformLogicalAnd = 362,

-    OpGroupNonUniformLogicalOr = 363,

-    OpGroupNonUniformLogicalXor = 364,

-    OpGroupNonUniformQuadBroadcast = 365,

-    OpGroupNonUniformQuadSwap = 366,

-    OpCopyLogical = 400,

-    OpPtrEqual = 401,

-    OpPtrNotEqual = 402,

-    OpPtrDiff = 403,

-    OpTerminateInvocation = 4416,

-    OpSubgroupBallotKHR = 4421,

-    OpSubgroupFirstInvocationKHR = 4422,

-    OpSubgroupAllKHR = 4428,

-    OpSubgroupAnyKHR = 4429,

-    OpSubgroupAllEqualKHR = 4430,

-    OpSubgroupReadInvocationKHR = 4432,

-    OpTraceRayKHR = 4445,

-    OpExecuteCallableKHR = 4446,

-    OpConvertUToAccelerationStructureKHR = 4447,

-    OpIgnoreIntersectionKHR = 4448,

-    OpTerminateRayKHR = 4449,

-    OpSDot = 4450,

-    OpSDotKHR = 4450,

-    OpUDot = 4451,

-    OpUDotKHR = 4451,

-    OpSUDot = 4452,

-    OpSUDotKHR = 4452,

-    OpSDotAccSat = 4453,

-    OpSDotAccSatKHR = 4453,

-    OpUDotAccSat = 4454,

-    OpUDotAccSatKHR = 4454,

-    OpSUDotAccSat = 4455,

-    OpSUDotAccSatKHR = 4455,

-    OpTypeRayQueryKHR = 4472,

-    OpRayQueryInitializeKHR = 4473,

-    OpRayQueryTerminateKHR = 4474,

-    OpRayQueryGenerateIntersectionKHR = 4475,

-    OpRayQueryConfirmIntersectionKHR = 4476,

-    OpRayQueryProceedKHR = 4477,

-    OpRayQueryGetIntersectionTypeKHR = 4479,

-    OpGroupIAddNonUniformAMD = 5000,

-    OpGroupFAddNonUniformAMD = 5001,

-    OpGroupFMinNonUniformAMD = 5002,

-    OpGroupUMinNonUniformAMD = 5003,

-    OpGroupSMinNonUniformAMD = 5004,

-    OpGroupFMaxNonUniformAMD = 5005,

-    OpGroupUMaxNonUniformAMD = 5006,

-    OpGroupSMaxNonUniformAMD = 5007,

-    OpFragmentMaskFetchAMD = 5011,

-    OpFragmentFetchAMD = 5012,

-    OpReadClockKHR = 5056,

-    OpImageSampleFootprintNV = 5283,

-    OpEmitMeshTasksEXT = 5294,

-    OpSetMeshOutputsEXT = 5295,

-    OpGroupNonUniformPartitionNV = 5296,

-    OpWritePackedPrimitiveIndices4x8NV = 5299,

-    OpReportIntersectionKHR = 5334,

-    OpReportIntersectionNV = 5334,

-    OpIgnoreIntersectionNV = 5335,

-    OpTerminateRayNV = 5336,

-    OpTraceNV = 5337,

-    OpTraceMotionNV = 5338,

-    OpTraceRayMotionNV = 5339,

-    OpTypeAccelerationStructureKHR = 5341,

-    OpTypeAccelerationStructureNV = 5341,

-    OpExecuteCallableNV = 5344,

-    OpTypeCooperativeMatrixNV = 5358,

-    OpCooperativeMatrixLoadNV = 5359,

-    OpCooperativeMatrixStoreNV = 5360,

-    OpCooperativeMatrixMulAddNV = 5361,

-    OpCooperativeMatrixLengthNV = 5362,

-    OpBeginInvocationInterlockEXT = 5364,

-    OpEndInvocationInterlockEXT = 5365,

-    OpDemoteToHelperInvocation = 5380,

-    OpDemoteToHelperInvocationEXT = 5380,

-    OpIsHelperInvocationEXT = 5381,

-    OpConvertUToImageNV = 5391,

-    OpConvertUToSamplerNV = 5392,

-    OpConvertImageToUNV = 5393,

-    OpConvertSamplerToUNV = 5394,

-    OpConvertUToSampledImageNV = 5395,

-    OpConvertSampledImageToUNV = 5396,

-    OpSamplerImageAddressingModeNV = 5397,

-    OpSubgroupShuffleINTEL = 5571,

-    OpSubgroupShuffleDownINTEL = 5572,

-    OpSubgroupShuffleUpINTEL = 5573,

-    OpSubgroupShuffleXorINTEL = 5574,

-    OpSubgroupBlockReadINTEL = 5575,

-    OpSubgroupBlockWriteINTEL = 5576,

-    OpSubgroupImageBlockReadINTEL = 5577,

-    OpSubgroupImageBlockWriteINTEL = 5578,

-    OpSubgroupImageMediaBlockReadINTEL = 5580,

-    OpSubgroupImageMediaBlockWriteINTEL = 5581,

-    OpUCountLeadingZerosINTEL = 5585,

-    OpUCountTrailingZerosINTEL = 5586,

-    OpAbsISubINTEL = 5587,

-    OpAbsUSubINTEL = 5588,

-    OpIAddSatINTEL = 5589,

-    OpUAddSatINTEL = 5590,

-    OpIAverageINTEL = 5591,

-    OpUAverageINTEL = 5592,

-    OpIAverageRoundedINTEL = 5593,

-    OpUAverageRoundedINTEL = 5594,

-    OpISubSatINTEL = 5595,

-    OpUSubSatINTEL = 5596,

-    OpIMul32x16INTEL = 5597,

-    OpUMul32x16INTEL = 5598,

-    OpConstantFunctionPointerINTEL = 5600,

-    OpFunctionPointerCallINTEL = 5601,

-    OpAsmTargetINTEL = 5609,

-    OpAsmINTEL = 5610,

-    OpAsmCallINTEL = 5611,

-    OpAtomicFMinEXT = 5614,

-    OpAtomicFMaxEXT = 5615,

-    OpAssumeTrueKHR = 5630,

-    OpExpectKHR = 5631,

-    OpDecorateString = 5632,

-    OpDecorateStringGOOGLE = 5632,

-    OpMemberDecorateString = 5633,

-    OpMemberDecorateStringGOOGLE = 5633,

-    OpVmeImageINTEL = 5699,

-    OpTypeVmeImageINTEL = 5700,

-    OpTypeAvcImePayloadINTEL = 5701,

-    OpTypeAvcRefPayloadINTEL = 5702,

-    OpTypeAvcSicPayloadINTEL = 5703,

-    OpTypeAvcMcePayloadINTEL = 5704,

-    OpTypeAvcMceResultINTEL = 5705,

-    OpTypeAvcImeResultINTEL = 5706,

-    OpTypeAvcImeResultSingleReferenceStreamoutINTEL = 5707,

-    OpTypeAvcImeResultDualReferenceStreamoutINTEL = 5708,

-    OpTypeAvcImeSingleReferenceStreaminINTEL = 5709,

-    OpTypeAvcImeDualReferenceStreaminINTEL = 5710,

-    OpTypeAvcRefResultINTEL = 5711,

-    OpTypeAvcSicResultINTEL = 5712,

-    OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL = 5713,

-    OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL = 5714,

-    OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL = 5715,

-    OpSubgroupAvcMceSetInterShapePenaltyINTEL = 5716,

-    OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL = 5717,

-    OpSubgroupAvcMceSetInterDirectionPenaltyINTEL = 5718,

-    OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL = 5719,

-    OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL = 5720,

-    OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL = 5721,

-    OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL = 5722,

-    OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL = 5723,

-    OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL = 5724,

-    OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL = 5725,

-    OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL = 5726,

-    OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL = 5727,

-    OpSubgroupAvcMceSetAcOnlyHaarINTEL = 5728,

-    OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL = 5729,

-    OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL = 5730,

-    OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL = 5731,

-    OpSubgroupAvcMceConvertToImePayloadINTEL = 5732,

-    OpSubgroupAvcMceConvertToImeResultINTEL = 5733,

-    OpSubgroupAvcMceConvertToRefPayloadINTEL = 5734,

-    OpSubgroupAvcMceConvertToRefResultINTEL = 5735,

-    OpSubgroupAvcMceConvertToSicPayloadINTEL = 5736,

-    OpSubgroupAvcMceConvertToSicResultINTEL = 5737,

-    OpSubgroupAvcMceGetMotionVectorsINTEL = 5738,

-    OpSubgroupAvcMceGetInterDistortionsINTEL = 5739,

-    OpSubgroupAvcMceGetBestInterDistortionsINTEL = 5740,

-    OpSubgroupAvcMceGetInterMajorShapeINTEL = 5741,

-    OpSubgroupAvcMceGetInterMinorShapeINTEL = 5742,

-    OpSubgroupAvcMceGetInterDirectionsINTEL = 5743,

-    OpSubgroupAvcMceGetInterMotionVectorCountINTEL = 5744,

-    OpSubgroupAvcMceGetInterReferenceIdsINTEL = 5745,

-    OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL = 5746,

-    OpSubgroupAvcImeInitializeINTEL = 5747,

-    OpSubgroupAvcImeSetSingleReferenceINTEL = 5748,

-    OpSubgroupAvcImeSetDualReferenceINTEL = 5749,

-    OpSubgroupAvcImeRefWindowSizeINTEL = 5750,

-    OpSubgroupAvcImeAdjustRefOffsetINTEL = 5751,

-    OpSubgroupAvcImeConvertToMcePayloadINTEL = 5752,

-    OpSubgroupAvcImeSetMaxMotionVectorCountINTEL = 5753,

-    OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL = 5754,

-    OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL = 5755,

-    OpSubgroupAvcImeSetWeightedSadINTEL = 5756,

-    OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL = 5757,

-    OpSubgroupAvcImeEvaluateWithDualReferenceINTEL = 5758,

-    OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = 5759,

-    OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = 5760,

-    OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = 5761,

-    OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = 5762,

-    OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = 5763,

-    OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = 5764,

-    OpSubgroupAvcImeConvertToMceResultINTEL = 5765,

-    OpSubgroupAvcImeGetSingleReferenceStreaminINTEL = 5766,

-    OpSubgroupAvcImeGetDualReferenceStreaminINTEL = 5767,

-    OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL = 5768,

-    OpSubgroupAvcImeStripDualReferenceStreamoutINTEL = 5769,

-    OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = 5770,

-    OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = 5771,

-    OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = 5772,

-    OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = 5773,

-    OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = 5774,

-    OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = 5775,

-    OpSubgroupAvcImeGetBorderReachedINTEL = 5776,

-    OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL = 5777,

-    OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL = 5778,

-    OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL = 5779,

-    OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL = 5780,

-    OpSubgroupAvcFmeInitializeINTEL = 5781,

-    OpSubgroupAvcBmeInitializeINTEL = 5782,

-    OpSubgroupAvcRefConvertToMcePayloadINTEL = 5783,

-    OpSubgroupAvcRefSetBidirectionalMixDisableINTEL = 5784,

-    OpSubgroupAvcRefSetBilinearFilterEnableINTEL = 5785,

-    OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL = 5786,

-    OpSubgroupAvcRefEvaluateWithDualReferenceINTEL = 5787,

-    OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL = 5788,

-    OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL = 5789,

-    OpSubgroupAvcRefConvertToMceResultINTEL = 5790,

-    OpSubgroupAvcSicInitializeINTEL = 5791,

-    OpSubgroupAvcSicConfigureSkcINTEL = 5792,

-    OpSubgroupAvcSicConfigureIpeLumaINTEL = 5793,

-    OpSubgroupAvcSicConfigureIpeLumaChromaINTEL = 5794,

-    OpSubgroupAvcSicGetMotionVectorMaskINTEL = 5795,

-    OpSubgroupAvcSicConvertToMcePayloadINTEL = 5796,

-    OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL = 5797,

-    OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL = 5798,

-    OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL = 5799,

-    OpSubgroupAvcSicSetBilinearFilterEnableINTEL = 5800,

-    OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL = 5801,

-    OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL = 5802,

-    OpSubgroupAvcSicEvaluateIpeINTEL = 5803,

-    OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL = 5804,

-    OpSubgroupAvcSicEvaluateWithDualReferenceINTEL = 5805,

-    OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL = 5806,

-    OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL = 5807,

-    OpSubgroupAvcSicConvertToMceResultINTEL = 5808,

-    OpSubgroupAvcSicGetIpeLumaShapeINTEL = 5809,

-    OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL = 5810,

-    OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL = 5811,

-    OpSubgroupAvcSicGetPackedIpeLumaModesINTEL = 5812,

-    OpSubgroupAvcSicGetIpeChromaModeINTEL = 5813,

-    OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814,

-    OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815,

-    OpSubgroupAvcSicGetInterRawSadsINTEL = 5816,

-    OpVariableLengthArrayINTEL = 5818,

-    OpSaveMemoryINTEL = 5819,

-    OpRestoreMemoryINTEL = 5820,

-    OpArbitraryFloatSinCosPiINTEL = 5840,

-    OpArbitraryFloatCastINTEL = 5841,

-    OpArbitraryFloatCastFromIntINTEL = 5842,

-    OpArbitraryFloatCastToIntINTEL = 5843,

-    OpArbitraryFloatAddINTEL = 5846,

-    OpArbitraryFloatSubINTEL = 5847,

-    OpArbitraryFloatMulINTEL = 5848,

-    OpArbitraryFloatDivINTEL = 5849,

-    OpArbitraryFloatGTINTEL = 5850,

-    OpArbitraryFloatGEINTEL = 5851,

-    OpArbitraryFloatLTINTEL = 5852,

-    OpArbitraryFloatLEINTEL = 5853,

-    OpArbitraryFloatEQINTEL = 5854,

-    OpArbitraryFloatRecipINTEL = 5855,

-    OpArbitraryFloatRSqrtINTEL = 5856,

-    OpArbitraryFloatCbrtINTEL = 5857,

-    OpArbitraryFloatHypotINTEL = 5858,

-    OpArbitraryFloatSqrtINTEL = 5859,

-    OpArbitraryFloatLogINTEL = 5860,

-    OpArbitraryFloatLog2INTEL = 5861,

-    OpArbitraryFloatLog10INTEL = 5862,

-    OpArbitraryFloatLog1pINTEL = 5863,

-    OpArbitraryFloatExpINTEL = 5864,

-    OpArbitraryFloatExp2INTEL = 5865,

-    OpArbitraryFloatExp10INTEL = 5866,

-    OpArbitraryFloatExpm1INTEL = 5867,

-    OpArbitraryFloatSinINTEL = 5868,

-    OpArbitraryFloatCosINTEL = 5869,

-    OpArbitraryFloatSinCosINTEL = 5870,

-    OpArbitraryFloatSinPiINTEL = 5871,

-    OpArbitraryFloatCosPiINTEL = 5872,

-    OpArbitraryFloatASinINTEL = 5873,

-    OpArbitraryFloatASinPiINTEL = 5874,

-    OpArbitraryFloatACosINTEL = 5875,

-    OpArbitraryFloatACosPiINTEL = 5876,

-    OpArbitraryFloatATanINTEL = 5877,

-    OpArbitraryFloatATanPiINTEL = 5878,

-    OpArbitraryFloatATan2INTEL = 5879,

-    OpArbitraryFloatPowINTEL = 5880,

-    OpArbitraryFloatPowRINTEL = 5881,

-    OpArbitraryFloatPowNINTEL = 5882,

-    OpLoopControlINTEL = 5887,

-    OpFixedSqrtINTEL = 5923,

-    OpFixedRecipINTEL = 5924,

-    OpFixedRsqrtINTEL = 5925,

-    OpFixedSinINTEL = 5926,

-    OpFixedCosINTEL = 5927,

-    OpFixedSinCosINTEL = 5928,

-    OpFixedSinPiINTEL = 5929,

-    OpFixedCosPiINTEL = 5930,

-    OpFixedSinCosPiINTEL = 5931,

-    OpFixedLogINTEL = 5932,

-    OpFixedExpINTEL = 5933,

-    OpPtrCastToCrossWorkgroupINTEL = 5934,

-    OpCrossWorkgroupCastToPtrINTEL = 5938,

-    OpReadPipeBlockingINTEL = 5946,

-    OpWritePipeBlockingINTEL = 5947,

-    OpFPGARegINTEL = 5949,

-    OpRayQueryGetRayTMinKHR = 6016,

-    OpRayQueryGetRayFlagsKHR = 6017,

-    OpRayQueryGetIntersectionTKHR = 6018,

-    OpRayQueryGetIntersectionInstanceCustomIndexKHR = 6019,

-    OpRayQueryGetIntersectionInstanceIdKHR = 6020,

-    OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR = 6021,

-    OpRayQueryGetIntersectionGeometryIndexKHR = 6022,

-    OpRayQueryGetIntersectionPrimitiveIndexKHR = 6023,

-    OpRayQueryGetIntersectionBarycentricsKHR = 6024,

-    OpRayQueryGetIntersectionFrontFaceKHR = 6025,

-    OpRayQueryGetIntersectionCandidateAABBOpaqueKHR = 6026,

-    OpRayQueryGetIntersectionObjectRayDirectionKHR = 6027,

-    OpRayQueryGetIntersectionObjectRayOriginKHR = 6028,

-    OpRayQueryGetWorldRayDirectionKHR = 6029,

-    OpRayQueryGetWorldRayOriginKHR = 6030,

-    OpRayQueryGetIntersectionObjectToWorldKHR = 6031,

-    OpRayQueryGetIntersectionWorldToObjectKHR = 6032,

-    OpAtomicFAddEXT = 6035,

-    OpTypeBufferSurfaceINTEL = 6086,

-    OpTypeStructContinuedINTEL = 6090,

-    OpConstantCompositeContinuedINTEL = 6091,

-    OpSpecConstantCompositeContinuedINTEL = 6092,

-    OpMax = 0x7fffffff,

-};

-

-#ifdef SPV_ENABLE_UTILITY_CODE

-inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {

-    *hasResult = *hasResultType = false;

-    switch (opcode) {

-    default: /* unknown opcode */ break;

-    case OpNop: *hasResult = false; *hasResultType = false; break;

-    case OpUndef: *hasResult = true; *hasResultType = true; break;

-    case OpSourceContinued: *hasResult = false; *hasResultType = false; break;

-    case OpSource: *hasResult = false; *hasResultType = false; break;

-    case OpSourceExtension: *hasResult = false; *hasResultType = false; break;

-    case OpName: *hasResult = false; *hasResultType = false; break;

-    case OpMemberName: *hasResult = false; *hasResultType = false; break;

-    case OpString: *hasResult = true; *hasResultType = false; break;

-    case OpLine: *hasResult = false; *hasResultType = false; break;

-    case OpExtension: *hasResult = false; *hasResultType = false; break;

-    case OpExtInstImport: *hasResult = true; *hasResultType = false; break;

-    case OpExtInst: *hasResult = true; *hasResultType = true; break;

-    case OpMemoryModel: *hasResult = false; *hasResultType = false; break;

-    case OpEntryPoint: *hasResult = false; *hasResultType = false; break;

-    case OpExecutionMode: *hasResult = false; *hasResultType = false; break;

-    case OpCapability: *hasResult = false; *hasResultType = false; break;

-    case OpTypeVoid: *hasResult = true; *hasResultType = false; break;

-    case OpTypeBool: *hasResult = true; *hasResultType = false; break;

-    case OpTypeInt: *hasResult = true; *hasResultType = false; break;

-    case OpTypeFloat: *hasResult = true; *hasResultType = false; break;

-    case OpTypeVector: *hasResult = true; *hasResultType = false; break;

-    case OpTypeMatrix: *hasResult = true; *hasResultType = false; break;

-    case OpTypeImage: *hasResult = true; *hasResultType = false; break;

-    case OpTypeSampler: *hasResult = true; *hasResultType = false; break;

-    case OpTypeSampledImage: *hasResult = true; *hasResultType = false; break;

-    case OpTypeArray: *hasResult = true; *hasResultType = false; break;

-    case OpTypeRuntimeArray: *hasResult = true; *hasResultType = false; break;

-    case OpTypeStruct: *hasResult = true; *hasResultType = false; break;

-    case OpTypeOpaque: *hasResult = true; *hasResultType = false; break;

-    case OpTypePointer: *hasResult = true; *hasResultType = false; break;

-    case OpTypeFunction: *hasResult = true; *hasResultType = false; break;

-    case OpTypeEvent: *hasResult = true; *hasResultType = false; break;

-    case OpTypeDeviceEvent: *hasResult = true; *hasResultType = false; break;

-    case OpTypeReserveId: *hasResult = true; *hasResultType = false; break;

-    case OpTypeQueue: *hasResult = true; *hasResultType = false; break;

-    case OpTypePipe: *hasResult = true; *hasResultType = false; break;

-    case OpTypeForwardPointer: *hasResult = false; *hasResultType = false; break;

-    case OpConstantTrue: *hasResult = true; *hasResultType = true; break;

-    case OpConstantFalse: *hasResult = true; *hasResultType = true; break;

-    case OpConstant: *hasResult = true; *hasResultType = true; break;

-    case OpConstantComposite: *hasResult = true; *hasResultType = true; break;

-    case OpConstantSampler: *hasResult = true; *hasResultType = true; break;

-    case OpConstantNull: *hasResult = true; *hasResultType = true; break;

-    case OpSpecConstantTrue: *hasResult = true; *hasResultType = true; break;

-    case OpSpecConstantFalse: *hasResult = true; *hasResultType = true; break;

-    case OpSpecConstant: *hasResult = true; *hasResultType = true; break;

-    case OpSpecConstantComposite: *hasResult = true; *hasResultType = true; break;

-    case OpSpecConstantOp: *hasResult = true; *hasResultType = true; break;

-    case OpFunction: *hasResult = true; *hasResultType = true; break;

-    case OpFunctionParameter: *hasResult = true; *hasResultType = true; break;

-    case OpFunctionEnd: *hasResult = false; *hasResultType = false; break;

-    case OpFunctionCall: *hasResult = true; *hasResultType = true; break;

-    case OpVariable: *hasResult = true; *hasResultType = true; break;

-    case OpImageTexelPointer: *hasResult = true; *hasResultType = true; break;

-    case OpLoad: *hasResult = true; *hasResultType = true; break;

-    case OpStore: *hasResult = false; *hasResultType = false; break;

-    case OpCopyMemory: *hasResult = false; *hasResultType = false; break;

-    case OpCopyMemorySized: *hasResult = false; *hasResultType = false; break;

-    case OpAccessChain: *hasResult = true; *hasResultType = true; break;

-    case OpInBoundsAccessChain: *hasResult = true; *hasResultType = true; break;

-    case OpPtrAccessChain: *hasResult = true; *hasResultType = true; break;

-    case OpArrayLength: *hasResult = true; *hasResultType = true; break;

-    case OpGenericPtrMemSemantics: *hasResult = true; *hasResultType = true; break;

-    case OpInBoundsPtrAccessChain: *hasResult = true; *hasResultType = true; break;

-    case OpDecorate: *hasResult = false; *hasResultType = false; break;

-    case OpMemberDecorate: *hasResult = false; *hasResultType = false; break;

-    case OpDecorationGroup: *hasResult = true; *hasResultType = false; break;

-    case OpGroupDecorate: *hasResult = false; *hasResultType = false; break;

-    case OpGroupMemberDecorate: *hasResult = false; *hasResultType = false; break;

-    case OpVectorExtractDynamic: *hasResult = true; *hasResultType = true; break;

-    case OpVectorInsertDynamic: *hasResult = true; *hasResultType = true; break;

-    case OpVectorShuffle: *hasResult = true; *hasResultType = true; break;

-    case OpCompositeConstruct: *hasResult = true; *hasResultType = true; break;

-    case OpCompositeExtract: *hasResult = true; *hasResultType = true; break;

-    case OpCompositeInsert: *hasResult = true; *hasResultType = true; break;

-    case OpCopyObject: *hasResult = true; *hasResultType = true; break;

-    case OpTranspose: *hasResult = true; *hasResultType = true; break;

-    case OpSampledImage: *hasResult = true; *hasResultType = true; break;

-    case OpImageSampleImplicitLod: *hasResult = true; *hasResultType = true; break;

-    case OpImageSampleExplicitLod: *hasResult = true; *hasResultType = true; break;

-    case OpImageSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break;

-    case OpImageSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break;

-    case OpImageSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break;

-    case OpImageSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break;

-    case OpImageSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break;

-    case OpImageSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break;

-    case OpImageFetch: *hasResult = true; *hasResultType = true; break;

-    case OpImageGather: *hasResult = true; *hasResultType = true; break;

-    case OpImageDrefGather: *hasResult = true; *hasResultType = true; break;

-    case OpImageRead: *hasResult = true; *hasResultType = true; break;

-    case OpImageWrite: *hasResult = false; *hasResultType = false; break;

-    case OpImage: *hasResult = true; *hasResultType = true; break;

-    case OpImageQueryFormat: *hasResult = true; *hasResultType = true; break;

-    case OpImageQueryOrder: *hasResult = true; *hasResultType = true; break;

-    case OpImageQuerySizeLod: *hasResult = true; *hasResultType = true; break;

-    case OpImageQuerySize: *hasResult = true; *hasResultType = true; break;

-    case OpImageQueryLod: *hasResult = true; *hasResultType = true; break;

-    case OpImageQueryLevels: *hasResult = true; *hasResultType = true; break;

-    case OpImageQuerySamples: *hasResult = true; *hasResultType = true; break;

-    case OpConvertFToU: *hasResult = true; *hasResultType = true; break;

-    case OpConvertFToS: *hasResult = true; *hasResultType = true; break;

-    case OpConvertSToF: *hasResult = true; *hasResultType = true; break;

-    case OpConvertUToF: *hasResult = true; *hasResultType = true; break;

-    case OpUConvert: *hasResult = true; *hasResultType = true; break;

-    case OpSConvert: *hasResult = true; *hasResultType = true; break;

-    case OpFConvert: *hasResult = true; *hasResultType = true; break;

-    case OpQuantizeToF16: *hasResult = true; *hasResultType = true; break;

-    case OpConvertPtrToU: *hasResult = true; *hasResultType = true; break;

-    case OpSatConvertSToU: *hasResult = true; *hasResultType = true; break;

-    case OpSatConvertUToS: *hasResult = true; *hasResultType = true; break;

-    case OpConvertUToPtr: *hasResult = true; *hasResultType = true; break;

-    case OpPtrCastToGeneric: *hasResult = true; *hasResultType = true; break;

-    case OpGenericCastToPtr: *hasResult = true; *hasResultType = true; break;

-    case OpGenericCastToPtrExplicit: *hasResult = true; *hasResultType = true; break;

-    case OpBitcast: *hasResult = true; *hasResultType = true; break;

-    case OpSNegate: *hasResult = true; *hasResultType = true; break;

-    case OpFNegate: *hasResult = true; *hasResultType = true; break;

-    case OpIAdd: *hasResult = true; *hasResultType = true; break;

-    case OpFAdd: *hasResult = true; *hasResultType = true; break;

-    case OpISub: *hasResult = true; *hasResultType = true; break;

-    case OpFSub: *hasResult = true; *hasResultType = true; break;

-    case OpIMul: *hasResult = true; *hasResultType = true; break;

-    case OpFMul: *hasResult = true; *hasResultType = true; break;

-    case OpUDiv: *hasResult = true; *hasResultType = true; break;

-    case OpSDiv: *hasResult = true; *hasResultType = true; break;

-    case OpFDiv: *hasResult = true; *hasResultType = true; break;

-    case OpUMod: *hasResult = true; *hasResultType = true; break;

-    case OpSRem: *hasResult = true; *hasResultType = true; break;

-    case OpSMod: *hasResult = true; *hasResultType = true; break;

-    case OpFRem: *hasResult = true; *hasResultType = true; break;

-    case OpFMod: *hasResult = true; *hasResultType = true; break;

-    case OpVectorTimesScalar: *hasResult = true; *hasResultType = true; break;

-    case OpMatrixTimesScalar: *hasResult = true; *hasResultType = true; break;

-    case OpVectorTimesMatrix: *hasResult = true; *hasResultType = true; break;

-    case OpMatrixTimesVector: *hasResult = true; *hasResultType = true; break;

-    case OpMatrixTimesMatrix: *hasResult = true; *hasResultType = true; break;

-    case OpOuterProduct: *hasResult = true; *hasResultType = true; break;

-    case OpDot: *hasResult = true; *hasResultType = true; break;

-    case OpIAddCarry: *hasResult = true; *hasResultType = true; break;

-    case OpISubBorrow: *hasResult = true; *hasResultType = true; break;

-    case OpUMulExtended: *hasResult = true; *hasResultType = true; break;

-    case OpSMulExtended: *hasResult = true; *hasResultType = true; break;

-    case OpAny: *hasResult = true; *hasResultType = true; break;

-    case OpAll: *hasResult = true; *hasResultType = true; break;

-    case OpIsNan: *hasResult = true; *hasResultType = true; break;

-    case OpIsInf: *hasResult = true; *hasResultType = true; break;

-    case OpIsFinite: *hasResult = true; *hasResultType = true; break;

-    case OpIsNormal: *hasResult = true; *hasResultType = true; break;

-    case OpSignBitSet: *hasResult = true; *hasResultType = true; break;

-    case OpLessOrGreater: *hasResult = true; *hasResultType = true; break;

-    case OpOrdered: *hasResult = true; *hasResultType = true; break;

-    case OpUnordered: *hasResult = true; *hasResultType = true; break;

-    case OpLogicalEqual: *hasResult = true; *hasResultType = true; break;

-    case OpLogicalNotEqual: *hasResult = true; *hasResultType = true; break;

-    case OpLogicalOr: *hasResult = true; *hasResultType = true; break;

-    case OpLogicalAnd: *hasResult = true; *hasResultType = true; break;

-    case OpLogicalNot: *hasResult = true; *hasResultType = true; break;

-    case OpSelect: *hasResult = true; *hasResultType = true; break;

-    case OpIEqual: *hasResult = true; *hasResultType = true; break;

-    case OpINotEqual: *hasResult = true; *hasResultType = true; break;

-    case OpUGreaterThan: *hasResult = true; *hasResultType = true; break;

-    case OpSGreaterThan: *hasResult = true; *hasResultType = true; break;

-    case OpUGreaterThanEqual: *hasResult = true; *hasResultType = true; break;

-    case OpSGreaterThanEqual: *hasResult = true; *hasResultType = true; break;

-    case OpULessThan: *hasResult = true; *hasResultType = true; break;

-    case OpSLessThan: *hasResult = true; *hasResultType = true; break;

-    case OpULessThanEqual: *hasResult = true; *hasResultType = true; break;

-    case OpSLessThanEqual: *hasResult = true; *hasResultType = true; break;

-    case OpFOrdEqual: *hasResult = true; *hasResultType = true; break;

-    case OpFUnordEqual: *hasResult = true; *hasResultType = true; break;

-    case OpFOrdNotEqual: *hasResult = true; *hasResultType = true; break;

-    case OpFUnordNotEqual: *hasResult = true; *hasResultType = true; break;

-    case OpFOrdLessThan: *hasResult = true; *hasResultType = true; break;

-    case OpFUnordLessThan: *hasResult = true; *hasResultType = true; break;

-    case OpFOrdGreaterThan: *hasResult = true; *hasResultType = true; break;

-    case OpFUnordGreaterThan: *hasResult = true; *hasResultType = true; break;

-    case OpFOrdLessThanEqual: *hasResult = true; *hasResultType = true; break;

-    case OpFUnordLessThanEqual: *hasResult = true; *hasResultType = true; break;

-    case OpFOrdGreaterThanEqual: *hasResult = true; *hasResultType = true; break;

-    case OpFUnordGreaterThanEqual: *hasResult = true; *hasResultType = true; break;

-    case OpShiftRightLogical: *hasResult = true; *hasResultType = true; break;

-    case OpShiftRightArithmetic: *hasResult = true; *hasResultType = true; break;

-    case OpShiftLeftLogical: *hasResult = true; *hasResultType = true; break;

-    case OpBitwiseOr: *hasResult = true; *hasResultType = true; break;

-    case OpBitwiseXor: *hasResult = true; *hasResultType = true; break;

-    case OpBitwiseAnd: *hasResult = true; *hasResultType = true; break;

-    case OpNot: *hasResult = true; *hasResultType = true; break;

-    case OpBitFieldInsert: *hasResult = true; *hasResultType = true; break;

-    case OpBitFieldSExtract: *hasResult = true; *hasResultType = true; break;

-    case OpBitFieldUExtract: *hasResult = true; *hasResultType = true; break;

-    case OpBitReverse: *hasResult = true; *hasResultType = true; break;

-    case OpBitCount: *hasResult = true; *hasResultType = true; break;

-    case OpDPdx: *hasResult = true; *hasResultType = true; break;

-    case OpDPdy: *hasResult = true; *hasResultType = true; break;

-    case OpFwidth: *hasResult = true; *hasResultType = true; break;

-    case OpDPdxFine: *hasResult = true; *hasResultType = true; break;

-    case OpDPdyFine: *hasResult = true; *hasResultType = true; break;

-    case OpFwidthFine: *hasResult = true; *hasResultType = true; break;

-    case OpDPdxCoarse: *hasResult = true; *hasResultType = true; break;

-    case OpDPdyCoarse: *hasResult = true; *hasResultType = true; break;

-    case OpFwidthCoarse: *hasResult = true; *hasResultType = true; break;

-    case OpEmitVertex: *hasResult = false; *hasResultType = false; break;

-    case OpEndPrimitive: *hasResult = false; *hasResultType = false; break;

-    case OpEmitStreamVertex: *hasResult = false; *hasResultType = false; break;

-    case OpEndStreamPrimitive: *hasResult = false; *hasResultType = false; break;

-    case OpControlBarrier: *hasResult = false; *hasResultType = false; break;

-    case OpMemoryBarrier: *hasResult = false; *hasResultType = false; break;

-    case OpAtomicLoad: *hasResult = true; *hasResultType = true; break;

-    case OpAtomicStore: *hasResult = false; *hasResultType = false; break;

-    case OpAtomicExchange: *hasResult = true; *hasResultType = true; break;

-    case OpAtomicCompareExchange: *hasResult = true; *hasResultType = true; break;

-    case OpAtomicCompareExchangeWeak: *hasResult = true; *hasResultType = true; break;

-    case OpAtomicIIncrement: *hasResult = true; *hasResultType = true; break;

-    case OpAtomicIDecrement: *hasResult = true; *hasResultType = true; break;

-    case OpAtomicIAdd: *hasResult = true; *hasResultType = true; break;

-    case OpAtomicISub: *hasResult = true; *hasResultType = true; break;

-    case OpAtomicSMin: *hasResult = true; *hasResultType = true; break;

-    case OpAtomicUMin: *hasResult = true; *hasResultType = true; break;

-    case OpAtomicSMax: *hasResult = true; *hasResultType = true; break;

-    case OpAtomicUMax: *hasResult = true; *hasResultType = true; break;

-    case OpAtomicAnd: *hasResult = true; *hasResultType = true; break;

-    case OpAtomicOr: *hasResult = true; *hasResultType = true; break;

-    case OpAtomicXor: *hasResult = true; *hasResultType = true; break;

-    case OpPhi: *hasResult = true; *hasResultType = true; break;

-    case OpLoopMerge: *hasResult = false; *hasResultType = false; break;

-    case OpSelectionMerge: *hasResult = false; *hasResultType = false; break;

-    case OpLabel: *hasResult = true; *hasResultType = false; break;

-    case OpBranch: *hasResult = false; *hasResultType = false; break;

-    case OpBranchConditional: *hasResult = false; *hasResultType = false; break;

-    case OpSwitch: *hasResult = false; *hasResultType = false; break;

-    case OpKill: *hasResult = false; *hasResultType = false; break;

-    case OpReturn: *hasResult = false; *hasResultType = false; break;

-    case OpReturnValue: *hasResult = false; *hasResultType = false; break;

-    case OpUnreachable: *hasResult = false; *hasResultType = false; break;

-    case OpLifetimeStart: *hasResult = false; *hasResultType = false; break;

-    case OpLifetimeStop: *hasResult = false; *hasResultType = false; break;

-    case OpGroupAsyncCopy: *hasResult = true; *hasResultType = true; break;

-    case OpGroupWaitEvents: *hasResult = false; *hasResultType = false; break;

-    case OpGroupAll: *hasResult = true; *hasResultType = true; break;

-    case OpGroupAny: *hasResult = true; *hasResultType = true; break;

-    case OpGroupBroadcast: *hasResult = true; *hasResultType = true; break;

-    case OpGroupIAdd: *hasResult = true; *hasResultType = true; break;

-    case OpGroupFAdd: *hasResult = true; *hasResultType = true; break;

-    case OpGroupFMin: *hasResult = true; *hasResultType = true; break;

-    case OpGroupUMin: *hasResult = true; *hasResultType = true; break;

-    case OpGroupSMin: *hasResult = true; *hasResultType = true; break;

-    case OpGroupFMax: *hasResult = true; *hasResultType = true; break;

-    case OpGroupUMax: *hasResult = true; *hasResultType = true; break;

-    case OpGroupSMax: *hasResult = true; *hasResultType = true; break;

-    case OpReadPipe: *hasResult = true; *hasResultType = true; break;

-    case OpWritePipe: *hasResult = true; *hasResultType = true; break;

-    case OpReservedReadPipe: *hasResult = true; *hasResultType = true; break;

-    case OpReservedWritePipe: *hasResult = true; *hasResultType = true; break;

-    case OpReserveReadPipePackets: *hasResult = true; *hasResultType = true; break;

-    case OpReserveWritePipePackets: *hasResult = true; *hasResultType = true; break;

-    case OpCommitReadPipe: *hasResult = false; *hasResultType = false; break;

-    case OpCommitWritePipe: *hasResult = false; *hasResultType = false; break;

-    case OpIsValidReserveId: *hasResult = true; *hasResultType = true; break;

-    case OpGetNumPipePackets: *hasResult = true; *hasResultType = true; break;

-    case OpGetMaxPipePackets: *hasResult = true; *hasResultType = true; break;

-    case OpGroupReserveReadPipePackets: *hasResult = true; *hasResultType = true; break;

-    case OpGroupReserveWritePipePackets: *hasResult = true; *hasResultType = true; break;

-    case OpGroupCommitReadPipe: *hasResult = false; *hasResultType = false; break;

-    case OpGroupCommitWritePipe: *hasResult = false; *hasResultType = false; break;

-    case OpEnqueueMarker: *hasResult = true; *hasResultType = true; break;

-    case OpEnqueueKernel: *hasResult = true; *hasResultType = true; break;

-    case OpGetKernelNDrangeSubGroupCount: *hasResult = true; *hasResultType = true; break;

-    case OpGetKernelNDrangeMaxSubGroupSize: *hasResult = true; *hasResultType = true; break;

-    case OpGetKernelWorkGroupSize: *hasResult = true; *hasResultType = true; break;

-    case OpGetKernelPreferredWorkGroupSizeMultiple: *hasResult = true; *hasResultType = true; break;

-    case OpRetainEvent: *hasResult = false; *hasResultType = false; break;

-    case OpReleaseEvent: *hasResult = false; *hasResultType = false; break;

-    case OpCreateUserEvent: *hasResult = true; *hasResultType = true; break;

-    case OpIsValidEvent: *hasResult = true; *hasResultType = true; break;

-    case OpSetUserEventStatus: *hasResult = false; *hasResultType = false; break;

-    case OpCaptureEventProfilingInfo: *hasResult = false; *hasResultType = false; break;

-    case OpGetDefaultQueue: *hasResult = true; *hasResultType = true; break;

-    case OpBuildNDRange: *hasResult = true; *hasResultType = true; break;

-    case OpImageSparseSampleImplicitLod: *hasResult = true; *hasResultType = true; break;

-    case OpImageSparseSampleExplicitLod: *hasResult = true; *hasResultType = true; break;

-    case OpImageSparseSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break;

-    case OpImageSparseSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break;

-    case OpImageSparseSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break;

-    case OpImageSparseSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break;

-    case OpImageSparseSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break;

-    case OpImageSparseSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break;

-    case OpImageSparseFetch: *hasResult = true; *hasResultType = true; break;

-    case OpImageSparseGather: *hasResult = true; *hasResultType = true; break;

-    case OpImageSparseDrefGather: *hasResult = true; *hasResultType = true; break;

-    case OpImageSparseTexelsResident: *hasResult = true; *hasResultType = true; break;

-    case OpNoLine: *hasResult = false; *hasResultType = false; break;

-    case OpAtomicFlagTestAndSet: *hasResult = true; *hasResultType = true; break;

-    case OpAtomicFlagClear: *hasResult = false; *hasResultType = false; break;

-    case OpImageSparseRead: *hasResult = true; *hasResultType = true; break;

-    case OpSizeOf: *hasResult = true; *hasResultType = true; break;

-    case OpTypePipeStorage: *hasResult = true; *hasResultType = false; break;

-    case OpConstantPipeStorage: *hasResult = true; *hasResultType = true; break;

-    case OpCreatePipeFromPipeStorage: *hasResult = true; *hasResultType = true; break;

-    case OpGetKernelLocalSizeForSubgroupCount: *hasResult = true; *hasResultType = true; break;

-    case OpGetKernelMaxNumSubgroups: *hasResult = true; *hasResultType = true; break;

-    case OpTypeNamedBarrier: *hasResult = true; *hasResultType = false; break;

-    case OpNamedBarrierInitialize: *hasResult = true; *hasResultType = true; break;

-    case OpMemoryNamedBarrier: *hasResult = false; *hasResultType = false; break;

-    case OpModuleProcessed: *hasResult = false; *hasResultType = false; break;

-    case OpExecutionModeId: *hasResult = false; *hasResultType = false; break;

-    case OpDecorateId: *hasResult = false; *hasResultType = false; break;

-    case OpGroupNonUniformElect: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformAll: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformAny: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformAllEqual: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformBroadcast: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformBroadcastFirst: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformBallot: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformInverseBallot: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformBallotBitExtract: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformBallotBitCount: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformBallotFindLSB: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformBallotFindMSB: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformShuffle: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformShuffleXor: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformShuffleUp: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformShuffleDown: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformIAdd: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformFAdd: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformIMul: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformFMul: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformSMin: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformUMin: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformFMin: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformSMax: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformUMax: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformFMax: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformBitwiseAnd: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformBitwiseOr: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformBitwiseXor: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformLogicalAnd: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformLogicalOr: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformLogicalXor: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformQuadBroadcast: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformQuadSwap: *hasResult = true; *hasResultType = true; break;

-    case OpCopyLogical: *hasResult = true; *hasResultType = true; break;

-    case OpPtrEqual: *hasResult = true; *hasResultType = true; break;

-    case OpPtrNotEqual: *hasResult = true; *hasResultType = true; break;

-    case OpPtrDiff: *hasResult = true; *hasResultType = true; break;

-    case OpTerminateInvocation: *hasResult = false; *hasResultType = false; break;

-    case OpSubgroupBallotKHR: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupFirstInvocationKHR: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAllKHR: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAnyKHR: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break;

-    case OpTraceRayKHR: *hasResult = false; *hasResultType = false; break;

-    case OpExecuteCallableKHR: *hasResult = false; *hasResultType = false; break;

-    case OpConvertUToAccelerationStructureKHR: *hasResult = true; *hasResultType = true; break;

-    case OpIgnoreIntersectionKHR: *hasResult = false; *hasResultType = false; break;

-    case OpTerminateRayKHR: *hasResult = false; *hasResultType = false; break;

-    case OpSDot: *hasResult = true; *hasResultType = true; break;

-    case OpUDot: *hasResult = true; *hasResultType = true; break;

-    case OpSUDot: *hasResult = true; *hasResultType = true; break;

-    case OpSDotAccSat: *hasResult = true; *hasResultType = true; break;

-    case OpUDotAccSat: *hasResult = true; *hasResultType = true; break;

-    case OpSUDotAccSat: *hasResult = true; *hasResultType = true; break;

-    case OpTypeRayQueryKHR: *hasResult = true; *hasResultType = false; break;

-    case OpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break;

-    case OpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break;

-    case OpRayQueryGenerateIntersectionKHR: *hasResult = false; *hasResultType = false; break;

-    case OpRayQueryConfirmIntersectionKHR: *hasResult = false; *hasResultType = false; break;

-    case OpRayQueryProceedKHR: *hasResult = true; *hasResultType = true; break;

-    case OpRayQueryGetIntersectionTypeKHR: *hasResult = true; *hasResultType = true; break;

-    case OpGroupIAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;

-    case OpGroupFAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;

-    case OpGroupFMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;

-    case OpGroupUMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;

-    case OpGroupSMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;

-    case OpGroupFMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;

-    case OpGroupUMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;

-    case OpGroupSMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;

-    case OpFragmentMaskFetchAMD: *hasResult = true; *hasResultType = true; break;

-    case OpFragmentFetchAMD: *hasResult = true; *hasResultType = true; break;

-    case OpReadClockKHR: *hasResult = true; *hasResultType = true; break;

-    case OpImageSampleFootprintNV: *hasResult = true; *hasResultType = true; break;

-    case OpGroupNonUniformPartitionNV: *hasResult = true; *hasResultType = true; break;

-    case OpEmitMeshTasksEXT: *hasResult = false; *hasResultType = false; break;

-    case OpSetMeshOutputsEXT: *hasResult = false; *hasResultType = false; break;

-    case OpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break;

-    case OpReportIntersectionNV: *hasResult = true; *hasResultType = true; break;

-    case OpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break;

-    case OpTerminateRayNV: *hasResult = false; *hasResultType = false; break;

-    case OpTraceNV: *hasResult = false; *hasResultType = false; break;

-    case OpTraceMotionNV: *hasResult = false; *hasResultType = false; break;

-    case OpTraceRayMotionNV: *hasResult = false; *hasResultType = false; break;

-    case OpTypeAccelerationStructureNV: *hasResult = true; *hasResultType = false; break;

-    case OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break;

-    case OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break;

-    case OpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break;

-    case OpCooperativeMatrixStoreNV: *hasResult = false; *hasResultType = false; break;

-    case OpCooperativeMatrixMulAddNV: *hasResult = true; *hasResultType = true; break;

-    case OpCooperativeMatrixLengthNV: *hasResult = true; *hasResultType = true; break;

-    case OpBeginInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break;

-    case OpEndInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break;

-    case OpDemoteToHelperInvocation: *hasResult = false; *hasResultType = false; break;

-    case OpIsHelperInvocationEXT: *hasResult = true; *hasResultType = true; break;

-    case OpConvertUToImageNV: *hasResult = true; *hasResultType = true; break;

-    case OpConvertUToSamplerNV: *hasResult = true; *hasResultType = true; break;

-    case OpConvertImageToUNV: *hasResult = true; *hasResultType = true; break;

-    case OpConvertSamplerToUNV: *hasResult = true; *hasResultType = true; break;

-    case OpConvertUToSampledImageNV: *hasResult = true; *hasResultType = true; break;

-    case OpConvertSampledImageToUNV: *hasResult = true; *hasResultType = true; break;

-    case OpSamplerImageAddressingModeNV: *hasResult = false; *hasResultType = false; break;

-    case OpSubgroupShuffleINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupShuffleDownINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupShuffleUpINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupShuffleXorINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupBlockReadINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;

-    case OpSubgroupImageBlockReadINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupImageBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;

-    case OpSubgroupImageMediaBlockReadINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupImageMediaBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;

-    case OpUCountLeadingZerosINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpUCountTrailingZerosINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpAbsISubINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpAbsUSubINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpIAddSatINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpUAddSatINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpIAverageINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpUAverageINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpIAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpUAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpISubSatINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpUSubSatINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpIMul32x16INTEL: *hasResult = true; *hasResultType = true; break;

-    case OpUMul32x16INTEL: *hasResult = true; *hasResultType = true; break;

-    case OpConstantFunctionPointerINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpFunctionPointerCallINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpAsmTargetINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpAsmINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpAsmCallINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpAtomicFMinEXT: *hasResult = true; *hasResultType = true; break;

-    case OpAtomicFMaxEXT: *hasResult = true; *hasResultType = true; break;

-    case OpAssumeTrueKHR: *hasResult = false; *hasResultType = false; break;

-    case OpExpectKHR: *hasResult = true; *hasResultType = true; break;

-    case OpDecorateString: *hasResult = false; *hasResultType = false; break;

-    case OpMemberDecorateString: *hasResult = false; *hasResultType = false; break;

-    case OpVmeImageINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpTypeVmeImageINTEL: *hasResult = true; *hasResultType = false; break;

-    case OpTypeAvcImePayloadINTEL: *hasResult = true; *hasResultType = false; break;

-    case OpTypeAvcRefPayloadINTEL: *hasResult = true; *hasResultType = false; break;

-    case OpTypeAvcSicPayloadINTEL: *hasResult = true; *hasResultType = false; break;

-    case OpTypeAvcMcePayloadINTEL: *hasResult = true; *hasResultType = false; break;

-    case OpTypeAvcMceResultINTEL: *hasResult = true; *hasResultType = false; break;

-    case OpTypeAvcImeResultINTEL: *hasResult = true; *hasResultType = false; break;

-    case OpTypeAvcImeResultSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break;

-    case OpTypeAvcImeResultDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break;

-    case OpTypeAvcImeSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break;

-    case OpTypeAvcImeDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break;

-    case OpTypeAvcRefResultINTEL: *hasResult = true; *hasResultType = false; break;

-    case OpTypeAvcSicResultINTEL: *hasResult = true; *hasResultType = false; break;

-    case OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceSetInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceSetInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceSetAcOnlyHaarINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceConvertToImePayloadINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceConvertToImeResultINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceConvertToRefPayloadINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceConvertToRefResultINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceConvertToSicPayloadINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceConvertToSicResultINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceGetMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceGetInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceGetBestInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceGetInterMajorShapeINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceGetInterMinorShapeINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceGetInterDirectionsINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceGetInterMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceGetInterReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeInitializeINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeSetSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeSetDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeRefWindowSizeINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeAdjustRefOffsetINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeSetMaxMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeSetWeightedSadINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeGetSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeGetDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeStripDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeGetBorderReachedINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcFmeInitializeINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcBmeInitializeINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcRefConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcRefSetBidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcRefSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSubgroupAvcRefEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;

-    case OpSu