Merge remote-tracking branch 'upstream/sdk-1.3.231' into main

Bug: 112606
Change-Id: Icbf28c5b65557e9087e32c85b2b5a4aa55ab484e
diff --git a/.appveyor.yml b/.appveyor.yml
index bf8c572..b08c47b 100644
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -98,7 +98,7 @@
     auth_token:
       secure: YglcSYdl0TylEa59H4K6lylBEDr586NAt2EMgZquSo+iuPrwgZQuJLPCoihSm9y6
     release: master-tot
-    description: "Continuous build of the latest master branch by Appveyor and Travis CI"
+    description: "Continuous build of the latest master branch by Appveyor and Github"
     artifact: artifacts-zip
     draft: false
     prerelease: false
diff --git a/.github/workflows/continuous_deployment.yml b/.github/workflows/continuous_deployment.yml
new file mode 100644
index 0000000..c375ac4
--- /dev/null
+++ b/.github/workflows/continuous_deployment.yml
@@ -0,0 +1,170 @@
+# NOTE: This workflow was ported from Travis.
+# Travis was using Ubuntu 14.04. Ubuntu 14.04 is not supportted by GitHub workflows. Ubuntu 20.04 is recommended.
+# Travis was using Clang 3.6. The earliest version support by Ubuntu 20.04 is Clang 6.0.
+# Travis was caching the clang package. APT package caching is not natively supported by GitHub actions/cache.
+# Travis was using Mac OS X 10.13.6 / Xcode 9.4.1 / LLVM 9.1.0
+
+# NOTE: The following documentation may be useful to maintainers of this workflow.
+# Github actions: https://docs.github.com/en/actions
+# Github github-script action: https://github.com/actions/github-script
+# GitHub REST API: https://docs.github.com/en/rest
+# Octokit front-end to the GitHub REST API: https://octokit.github.io/rest.js/v18
+# Octokit endpoint methods: https://github.com/octokit/plugin-rest-endpoint-methods.js/tree/master/docs/repos
+
+# TODO: Use actions/upload-artifact and actions/download-artifact to simplify deployment.
+# TODO: Use composite actions to refactor redundant code.
+
+name: Continuous Deployment
+
+on:
+    workflow_dispatch:
+    push:
+        branches:
+            - master
+
+jobs:
+    linux:
+        runs-on: ${{matrix.os.genus}}
+        strategy:
+            fail-fast: false
+            matrix:
+                os: [{genus: ubuntu-20.04, family: linux}]
+                compiler: [{cc: clang, cxx: clang++}, {cc: gcc, cxx: g++}]
+                cmake_build_type: [Debug, Release]
+        steps:
+            - uses: actions/checkout@v2
+            - uses: actions/setup-python@v2
+              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: 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: Build
+              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: Test
+              run: |
+                  cd build
+                  ctest --output-on-failure &&
+                  cd ../Test && ./runtests
+            - name: Zip
+              if: ${{ matrix.compiler.cc == 'clang' }}
+              env:
+                  ARCHIVE: glslang-master-${{matrix.os.family}}-${{matrix.cmake_build_type}}.zip
+              run: |
+                  cd build/install
+                  zip ${ARCHIVE} \
+                      bin/glslangValidator \
+                      include/glslang/* \
+                      include/glslang/**/* \
+                      lib/libGenericCodeGen.a \
+                      lib/libglslang.a \
+                      lib/libglslang-default-resource-limits.a \
+                      lib/libHLSL.a \
+                      lib/libMachineIndependent.a \
+                      lib/libOGLCompiler.a \
+                      lib/libOSDependent.a \
+                      lib/libSPIRV.a \
+                      lib/libSPVRemapper.a \
+                      lib/libSPIRV-Tools.a \
+                      lib/libSPIRV-Tools-opt.a
+            - name: Deploy
+              if: ${{ matrix.compiler.cc == 'clang' }}
+              env:
+                  ARCHIVE: glslang-master-${{matrix.os.family}}-${{matrix.cmake_build_type}}.zip
+              uses: actions/github-script@v5
+              with:
+                  script: |
+                      const script = require('.github/workflows/deploy.js')
+                      await script({github, context, core})
+
+    macos:
+        runs-on: ${{matrix.os.genus}}
+        strategy:
+            fail-fast: false
+            matrix:
+                os: [{genus: macos-11, family: osx}]
+                compiler: [{cc: clang, cxx: clang++}]
+                cmake_build_type: [Debug, Release]
+        steps:
+            - uses: actions/checkout@v2
+            - uses: actions/setup-python@v2
+              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: |
+                  ./update_glslang_sources.py
+            - name: Build
+              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: Test
+              run: |
+                  cd build
+                  ctest --output-on-failure &&
+                  cd ../Test && ./runtests
+            - name: Zip
+              env:
+                  ARCHIVE: glslang-master-${{matrix.os.family}}-${{matrix.cmake_build_type}}.zip
+              run: |
+                  cd build/install
+                  zip ${ARCHIVE} \
+                      bin/glslangValidator \
+                      include/glslang/* \
+                      include/glslang/**/* \
+                      lib/libGenericCodeGen.a \
+                      lib/libglslang.a \
+                      lib/libglslang-default-resource-limits.a \
+                      lib/libHLSL.a \
+                      lib/libMachineIndependent.a \
+                      lib/libOGLCompiler.a \
+                      lib/libOSDependent.a \
+                      lib/libSPIRV.a \
+                      lib/libSPVRemapper.a \
+                      lib/libSPIRV-Tools.a \
+                      lib/libSPIRV-Tools-opt.a
+            - name: Deploy
+              env:
+                  ARCHIVE: glslang-master-${{matrix.os.family}}-${{matrix.cmake_build_type}}.zip
+              uses: actions/github-script@v5
+              with:
+                  script: |
+                      const script = require('.github/workflows/deploy.js')
+                      await script({github, context, core})
diff --git a/.github/workflows/continuous_integration.yml b/.github/workflows/continuous_integration.yml
new file mode 100644
index 0000000..7c36c68
--- /dev/null
+++ b/.github/workflows/continuous_integration.yml
@@ -0,0 +1,157 @@
+# NOTE: This workflow was ported from Travis.
+# Travis was using Ubuntu 14.04. Ubuntu 14.04 is not supportted by GitHub workflows. Ubuntu 20.04 is recommended.
+# Travis was using Clang 3.6. The earliest version support by Ubuntu 20.04 is Clang 6.0.
+# Travis was caching the clang package. APT package caching is not natively supported by GitHub actions/cache.
+# Travis was using Mac OS X 10.13.6 / Xcode 9.4.1 / LLVM 9.1.0
+#
+name: Continuous Integration
+
+on:
+    workflow_dispatch:
+    pull_request:
+        branches:
+            - master
+
+jobs:
+    linux:
+        runs-on: ${{matrix.os}}
+        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
+              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: 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: Build
+              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: 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++}]
+                cmake_build_type: [Debug, Release]
+        steps:
+            - uses: actions/checkout@v2
+            - uses: actions/setup-python@v2
+              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: |
+                  ./update_glslang_sources.py
+            - name: Build
+              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: Test
+              run: |
+                  cd build
+                  ctest --output-on-failure &&
+                  cd ../Test && ./runtests
+
+    android:
+        runs-on: ${{matrix.os}}
+        strategy:
+            fail-fast: false
+            matrix:
+                os: [ubuntu-20.04]
+                compiler: [{cc: clang, cxx: clang++}]
+                cmake_build_type: [Release]
+        steps:
+            - uses: actions/checkout@v2
+            - uses: actions/setup-python@v2
+              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
+                  # 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: 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
diff --git a/.github/workflows/deploy.js b/.github/workflows/deploy.js
new file mode 100644
index 0000000..9f8d242
--- /dev/null
+++ b/.github/workflows/deploy.js
@@ -0,0 +1,73 @@
+module.exports = async ({github, context, core}) => {
+    try {
+        await github.rest.git.updateRef({
+            owner: context.repo.owner,
+            repo: context.repo.repo,
+            ref: 'tags/master-tot',
+            sha: context.sha
+        })
+    } catch (error) {
+        core.setFailed(`upload master-tot tag; ${error.name}; ${error.message}`)
+    }
+
+    let release
+    try {
+        release = await github.rest.repos.getReleaseByTag({
+            owner: context.repo.owner,
+            repo: context.repo.repo,
+            tag: 'master-tot'
+        })
+    } catch (error) {
+        core.setFailed(`get the master release; ${error.name}; ${error.message}`)
+    }
+
+    try {
+        await github.rest.repos.updateRelease({
+            owner: context.repo.owner,
+            repo: context.repo.repo,
+            release_id: release.data.id
+        })
+    } catch (error) {
+        core.setFailed(`update the master release; ${error.name}; ${error.message}`)
+    }
+
+    let release_assets
+    try {
+        release_assets = await github.rest.repos.listReleaseAssets({
+            owner: context.repo.owner,
+            repo: context.repo.repo,
+            release_id: release.data.id
+        })
+    } catch (error) {
+        core.setFailed(`list release assets; ${error.name}; ${error.message}`)
+    }
+
+    const { ARCHIVE } = process.env
+    for (const release_asset of release_assets.data) {
+        if (release_asset.name === `${ ARCHIVE }`) {
+            try {
+                await github.rest.repos.deleteReleaseAsset({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    asset_id: release_asset.id
+                })
+            } catch (error) {
+                core.setFailed(`delete ${ ARCHIVE }; ${error.name}; ${error.message}`)
+            }
+        }
+    }
+
+    try {
+        const asset_path = `./build/install/${ ARCHIVE }`
+        const fs = require("fs")
+        await github.rest.repos.uploadReleaseAsset({
+            owner: context.repo.owner,
+            repo: context.repo.repo,
+            release_id: release.data.id,
+            name: `${ ARCHIVE }`,
+            data: fs.readFileSync(asset_path)
+        })
+    } catch (error) {
+        core.setFailed(`upload ${ ARCHIVE }; ${error.name}; ${error.message}`)
+    }
+}
diff --git a/.gitignore b/.gitignore
index ab25cec..333fb76 100644
--- a/.gitignore
+++ b/.gitignore
@@ -18,3 +18,7 @@
 third_party/
 buildtools/
 tools/
+
+# Random OS stuff
+.DS_Store
+._*
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index cb0392e..0000000
--- a/.travis.yml
+++ /dev/null
@@ -1,141 +0,0 @@
-# Linux and Mac Build Configuration for Travis
-
-language: cpp
-
-os:
-  - linux
-  - osx
-
-# Use Ubuntu 14.04 LTS (Trusty) as the Linux testing environment.
-sudo: false
-dist: trusty
-
-env:
-  global:
-    - secure: aGFrgzyKp+84hKrGkxVWg8cHV61uqrKEHT38gfSQK6+WS4GfLOyH83p7WnsEBb7AMhzU7LMNFdvOFr6+NaMpVnqRvc40CEG1Q+lNg9Pq9mhIZLowvDrfqTL9kQ+8Nbw5Q6/dg6CTvY7fvRfpfCEmKIUZBRkoKUuHeuM1uy3IupFcdNuL5bSYn3Beo+apSJginh9DI4BLDXFUgBzTRSLLyCX5g3cpaeGGOCr8quJlYx75W6HRck5g9SZuLtUoH9GFEV3l+ZEWB8noErW+J56L03bwNwFuuAh321evw++oQk5KFa8rlDvar3SJ3b1RHB8u/eq5DBYMyaK/fS8+Q7QbGr8diF/wDe68bKO7U9IhpNfExXmczCpExjHomW5TQv4rYdGhygPMfW97aIsPRYyNKcl4fkmb7NDrM8w0Jscdq2g5c2Kz0ItyZoBri/NXLwFQQjaVCs7Pf97TjuMA7mK0GJmDTRzi6SrDYlWMt5BQL3y0CCojyfLIRcTh0CQjQI29s97bLfQrYAxt9GNNFR+HTXRLLrkaAlJkPGEPwUywlSfEThnvHLesNxYqemolAYpQT4ithoL4GehGIHmaxsW295aKVhuRf8K9eBODNqrfblvM42UHhjntT+92ZnQ/Gkq80GqaMxnxi4PO5FyPIxt0r981b54YBkWi8YA4P7w5pNI=
-  matrix:
-    - GLSLANG_BUILD_TYPE=Release
-    - GLSLANG_BUILD_TYPE=Debug
-
-compiler:
-  - clang
-  - gcc
-
-matrix:
-  fast_finish: true # Show final status immediately if a test fails.
-  exclude:
-    # Skip GCC builds on Mac OS X.
-    - os: osx
-      compiler: gcc
-  include:
-    # Additional build using Android NDK.
-    - env: BUILD_NDK=ON
-
-cache:
-  apt: true
-
-branches:
-  only:
-    - master
-
-addons:
-  apt:
-    packages:
-      - clang-3.6
-
-install:
-  # Make sure that clang-3.6 is selected on Linux.
-  - if [[ "$TRAVIS_OS_NAME" == "linux" && "$CC" == "clang" ]]; then
-      export CC=clang-3.6 CXX=clang++-3.6;
-    fi
-  # Download a recent Android NDK and use its android.toolchain.cmake file.
-  - if [[ "$BUILD_NDK" == "ON" ]]; then
-      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;
-      export TOOLCHAIN_PATH=$ANDROID_NDK/build/cmake/android.toolchain.cmake;
-    fi
-
-before_script:
-  # 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 ../..
-  # get spirv-tools and spirv-headers
-  - ./update_glslang_sources.py
-
-script:
-  - mkdir build && cd build
-  # For Android, do release building using NDK without testing.
-  # Use android-14, the oldest native API level supporeted by NDK r17b.
-  # We can use newer API levels if we want.
-  # For Linux and macOS, do debug/release building with testing.
-  - if [[ "$BUILD_NDK" == "ON" ]]; then
-      cmake -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_PATH}
-            -DANDROID_NATIVE_API_LEVEL=android-14
-            -DCMAKE_BUILD_TYPE=Release
-            -DANDROID_ABI="armeabi-v7a with NEON"
-            -DBUILD_TESTING=OFF ..;
-      make -j4;
-    else
-      cmake -DCMAKE_BUILD_TYPE=${GLSLANG_BUILD_TYPE}
-            -DCMAKE_INSTALL_PREFIX=`pwd`/install ..;
-      make -j4 install;
-      ctest --output-on-failure &&
-      cd ../Test && ./runtests;
-    fi
-
-after_success:
-  # For debug build, the generated dll has a postfix "d" in its name.
-  - if [[ "${GLSLANG_BUILD_TYPE}" == "Debug" ]]; then
-      export SUFFIX="d";
-    else
-      export SUFFIX="";
-    fi
-  # Create tarball for deployment
-  - if [[ ${CC} == clang* && "${BUILD_NDK}" != "ON" ]]; then
-      cd ../build/install;
-      export TARBALL=glslang-master-${TRAVIS_OS_NAME}-${GLSLANG_BUILD_TYPE}.zip;
-      zip ${TARBALL}
-        bin/glslangValidator
-        include/glslang/*
-        lib/libGenericCodeGen${SUFFIX}.a
-        lib/libglslang${SUFFIX}.a
-        lib/libglslang-default-resource-limits${SUFFIX}.a
-        lib/libHLSL${SUFFIX}.a
-        lib/libMachineIndependent${SUFFIX}.a
-        lib/libOGLCompiler${SUFFIX}.a
-        lib/libOSDependent${SUFFIX}.a
-        lib/libSPIRV${SUFFIX}.a
-        lib/libSPVRemapper${SUFFIX}.a
-        lib/libSPIRV-Tools${SUFFIX}.a
-        lib/libSPIRV-Tools-opt${SUFFIX}.a;
-    fi
-
-before_deploy:
-  # Tag the current top of the tree as "master-tot".
-  # Travis CI replies on the tag name to properly push to GitHub Releases.
-  - git config --global user.name "Travis CI"
-  - git config --global user.email "builds@travis-ci.org"
-  - git tag -f master-tot
-  - git push -q -f https://${glslangtoken}@github.com/KhronosGroup/glslang --tags
-
-deploy:
-  provider: releases
-  api_key: ${glslangtoken}
-  on:
-    branch: master
-    condition: ${CC} == clang* && ${BUILD_NDK} != ON
-  file: ${TARBALL}
-  skip_cleanup: true
-  overwrite: true
diff --git a/Android.mk b/Android.mk
index c9b221f..40cddb7 100644
--- a/Android.mk
+++ b/Android.mk
@@ -96,6 +96,7 @@
 LOCAL_CXXFLAGS:=-std=c++11 -fno-exceptions -fno-rtti $(GLSLANG_DEFINES)
 LOCAL_EXPORT_C_INCLUDES:=$(LOCAL_PATH)
 LOCAL_SRC_FILES:= \
+		glslang/CInterface/glslang_c_interface.cpp \
 		glslang/GenericCodeGen/CodeGen.cpp \
 		glslang/GenericCodeGen/Link.cpp \
 		glslang/HLSL/hlslAttributes.cpp \
@@ -149,6 +150,7 @@
 LOCAL_MODULE:=SPIRV
 LOCAL_CXXFLAGS:=-std=c++11 -fno-exceptions -fno-rtti -Werror $(GLSLANG_DEFINES)
 LOCAL_SRC_FILES:= \
+	SPIRV/CInterface/spirv_c_interface.cpp \
 	SPIRV/GlslangToSpv.cpp \
 	SPIRV/InReadableOrder.cpp \
 	SPIRV/Logger.cpp \
diff --git a/BUILD.bazel b/BUILD.bazel
index 1115b7d..12168fa 100644
--- a/BUILD.bazel
+++ b/BUILD.bazel
@@ -146,6 +146,7 @@
         "SPIRV/GLSL.ext.NV.h",
         "SPIRV/GLSL.std.450.h",
         "SPIRV/NonSemanticDebugPrintf.h",
+        "SPIRV/NonSemanticShaderDebugInfo100.h",
         "SPIRV/spirv.hpp",
     ],
     outs = [
@@ -155,6 +156,7 @@
         "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/",
diff --git a/BUILD.gn b/BUILD.gn
index 70e1068..928fad6 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -136,6 +136,7 @@
       "SPIRV/Logger.cpp",
       "SPIRV/Logger.h",
       "SPIRV/NonSemanticDebugPrintf.h",
+      "SPIRV/NonSemanticShaderDebugInfo100.h",
       "SPIRV/SPVRemapper.cpp",
       "SPIRV/SPVRemapper.h",
       "SPIRV/SpvBuilder.cpp",
diff --git a/CHANGES.md b/CHANGES.md
index ebab4da..e7b6f14 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -3,6 +3,47 @@
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](https://semver.org/).
 
+## 11.12.0 2022-10-12
+
+### Other changes
+* Update generator version
+* Add support for GL_EXT_mesh_shader
+* Add support for NonSemantic.Shader.DebugInfo.100
+* Make OpEmitMeshTasksEXT a terminal instruction
+* Make gl_SubGroupARB a flat in int in Vulkan
+* Add support for GL_EXT_opacity_micromap
+* Add preamble support to C interface
+
+## 11.11.0 2022-08-11
+
+### Other changes
+* Add OpSource support to C interface
+* Deprecate samplerBuffer for spirv1.6 and later
+* Add support for SPV_AMD_shader_early_and_late_fragment_tests
+
+## 11.10.0 2022-06-02
+
+### Other changes
+* Generate OpLine before OpFunction
+* Add support for VK_EXT_fragment_shader_barycentric
+* Add whitelist filtering for debug comments in SPIRV-Remap
+* Add support for GL_EXT_ray_cull_mask
+
+## 11.9.0 2022-04-06
+
+### Other changes
+* Add GLSL version override functionality
+* Add eliminate-dead-input-components to -Os
+* Add enhanced-msgs option
+* Explicitly use Python 3 for builds
+
+## 11.8.0 2022-01-27
+
+### Other changes
+* Add support for SPIR-V 1.6
+* Add support for Vulkan 1.3
+* Add --hlsl-dx-position-w option
+
 ## 11.7.0 2021-11-11
 
 ### Other changes
diff --git a/CMakeLists.txt b/CMakeLists.txt
index d5b727a..b581c84 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -33,7 +33,7 @@
 
 # increase to 3.1 once all major distributions
 # include a version of CMake >= 3.1
-cmake_minimum_required(VERSION 2.8.12)
+cmake_minimum_required(VERSION 3.14.0)
 if (POLICY CMP0048)
   cmake_policy(SET CMP0048 NEW)
 endif()
@@ -50,6 +50,7 @@
 
 # Adhere to GNU filesystem layout conventions
 include(GNUInstallDirs)
+include(CMakePackageConfigHelpers)
 
 # Needed for CMAKE_DEPENDENT_OPTION macro
 include(CMakeDependentOption)
@@ -106,10 +107,17 @@
 option(ENABLE_RTTI "Enables RTTI" OFF)
 option(ENABLE_EXCEPTIONS "Enables Exceptions" OFF)
 option(ENABLE_OPT "Enables spirv-opt capability if present" ON)
-option(ENABLE_PCH "Enables Precompiled header" ON)
+
+if(MINGW OR (CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND ${CMAKE_CXX_COMPILER_ID} MATCHES "GNU"))
+    # Workaround for CMake behavior on Mac OS with gcc, cmake generates -Xarch_* arguments
+    # which gcc rejects
+    option(ENABLE_PCH "Enables Precompiled header" OFF)
+else()
+    option(ENABLE_PCH "Enables Precompiled header" ON)
+endif()
 option(ENABLE_CTEST "Enables testing" ON)
 
-if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT AND WIN32)
+if(ENABLE_GLSLANG_INSTALL AND CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT AND WIN32)
     set(CMAKE_INSTALL_PREFIX "install" CACHE STRING "..." FORCE)
 endif()
 
@@ -163,7 +171,7 @@
         add_compile_options(-Werror=deprecated-copy)
     endif()
 
-    if(NOT CMAKE_VERSION VERSION_LESS "3.13")
+    if(NOT CMAKE_VERSION VERSION_LESS "3.13" 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.
@@ -184,7 +192,11 @@
         # 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,-undefined,error")
+        if (WIN32)
+            add_link_options("-Wl,--no-undefined")
+        else()
+            add_link_options("-Wl,-undefined,error")
+        endif()
     endif()
 elseif(MSVC)
     if(NOT ENABLE_RTTI)
@@ -356,3 +368,38 @@
         COMMAND bash ${IGNORE_CR_FLAG} runtests ${RESULTS_PATH} ${VALIDATOR_PATH} ${REMAP_PATH}
         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/Test/)
 endif()
+
+if(ENABLE_GLSLANG_INSTALL)
+    file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/glslang-config.cmake.in" [=[
+        @PACKAGE_INIT@
+        include("@PACKAGE_PATH_EXPORT_TARGETS@")
+    ]=])
+    
+    set(PATH_EXPORT_TARGETS "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}/glslang-targets.cmake")
+    configure_package_config_file(
+        "${CMAKE_CURRENT_BINARY_DIR}/glslang-config.cmake.in"
+        "${CMAKE_CURRENT_BINARY_DIR}/glslang-config.cmake"
+        PATH_VARS
+            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"
+            "${CMAKE_CURRENT_BINARY_DIR}/glslang-config-version.cmake"
+        DESTINATION
+            "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
+    )
+endif()
\ No newline at end of file
diff --git a/LICENSE.txt b/LICENSE.txt
index 5f58565..054e68a 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -303,41 +303,647 @@
 GPL 3 with special bison exception
 --------------------------------------------------------------------------------
 
-   Bison implementation for Yacc-like parsers in C
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
 
-   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
 
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
+                            Preamble
 
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
 
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
 
-   As a special exception, you may create a larger work that contains
-   part or all of the Bison parser skeleton and distribute that work
-   under terms of your choice, so long as that work isn't itself a
-   parser generator using the skeleton or a modified version thereof
-   as a parser skeleton.  Alternatively, if you modify or redistribute
-   the parser skeleton itself, you may (at your option) remove this
-   special exception, which will cause the skeleton and the resulting
-   Bison output files to be licensed under the GNU General Public
-   License without this special exception.
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
 
-   This special exception was added by the Free Software Foundation in
-   version 2.2 of Bison.
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+Bison Exception
+
+As a special exception, you may create a larger work that contains part or all
+of the Bison parser skeleton and distribute that work under terms of your
+choice, so long as that work isn't itself a parser generator using the skeleton
+or a modified version thereof as a parser skeleton.  Alternatively, if you
+modify or redistribute the parser skeleton itself, you may (at your option)
+remove this special exception, which will cause the skeleton and the resulting
+Bison output files to be licensed under the GNU General Public License without
+this special exception.
+
+This special exception was added by the Free Software Foundation in version
+2.2 of Bison.
+
+                     END OF TERMS AND CONDITIONS
 
 --------------------------------------------------------------------------------
 ================================================================================
 --------------------------------------------------------------------------------
 
-The preprocessor has the core licenses stated above, plus an additional licence:
+The preprocessor has the core licenses stated above, plus additional licences:
 
 /****************************************************************************\
 Copyright (c) 2002, NVIDIA Corporation.
@@ -382,3 +988,29 @@
 TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF
 NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 \****************************************************************************/
+
+/*
+** Copyright (c) 2014-2016 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.
+*/
diff --git a/OGLCompilersDLL/CMakeLists.txt b/OGLCompilersDLL/CMakeLists.txt
index 0b007d4..b44cbc7 100644
--- a/OGLCompilersDLL/CMakeLists.txt
+++ b/OGLCompilersDLL/CMakeLists.txt
@@ -41,8 +41,19 @@
     source_group("Source" FILES ${SOURCES})
 endif(WIN32)
 
-if(ENABLE_GLSLANG_INSTALL)
-    install(TARGETS OGLCompiler EXPORT OGLCompilerTargets
-            ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-	install(EXPORT OGLCompilerTargets DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
-endif(ENABLE_GLSLANG_INSTALL)
+if(ENABLE_GLSLANG_INSTALL AND NOT BUILD_SHARED_LIBS)
+    install(TARGETS OGLCompiler EXPORT glslang-targets)
+
+    # Backward compatibility
+    file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/OGLCompilerTargets.cmake" "
+        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\")
+        endif()
+
+        add_library(OGLCompiler ALIAS glslang::OGLCompiler)
+    ")
+    install(FILES "${CMAKE_CURRENT_BINARY_DIR}/OGLCompilerTargets.cmake" DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
+
+endif()
diff --git a/README.md b/README.md
index 9b8cfb3..5e642e6 100644
--- a/README.md
+++ b/README.md
@@ -19,8 +19,8 @@
 
 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.
 
-[![Build Status](https://travis-ci.org/KhronosGroup/glslang.svg?branch=master)](https://travis-ci.org/KhronosGroup/glslang)
-[![Build status](https://ci.appveyor.com/api/projects/status/q6fi9cb0qnhkla68/branch/master?svg=true)](https://ci.appveyor.com/project/Khronoswebmaster/glslang/branch/master)
+[![appveyor status](https://ci.appveyor.com/api/projects/status/q6fi9cb0qnhkla68/branch/master?svg=true)](https://ci.appveyor.com/project/Khronoswebmaster/glslang/branch/master)
+![Continuous Deployment](https://github.com/KhronosGroup/glslang/actions/workflows/continuous_deployment.yml/badge.svg)
 
 # Glslang Components and Status
 
@@ -85,7 +85,15 @@
 * `.frag` for a fragment shader
 * `.comp` for a compute shader
 
-There is also a non-shader extension
+For ray tracing pipeline shaders:
+* `.rgen` for a ray generation shader
+* `.rint` for a ray intersection shader
+* `.rahit` for a ray any-hit shader
+* `.rchit` for a ray closest-hit shader
+* `.rmiss` for a ray miss shader
+* `.rcall` for a callable shader
+
+There is also a non-shader extension:
 * `.conf` for a configuration file of limits, see usage statement for example
 
 ## Building (CMake)
@@ -161,8 +169,8 @@
 
 For building on Android:
 ```bash
-cmake $SOURCE_DIR -G "Unix Makefiles" -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DANDROID_ABI=arm64-v8a -DCMAKE_BUILD_TYPE=Release -DANDROID_STL=c++_static -DANDROID_PLATFORM=android-24 -DCMAKE_SYSTEM_NAME=Android -DANDROID_TOOLCHAIN=clang -DANDROID_ARM_MODE=arm -DCMAKE_MAKE_PROGRAM=$ANDROID_NDK_ROOT/prebuilt/linux-x86_64/bin/make -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK_ROOT/build/cmake/android.toolchain.cmake
-# If on Windows will be -DCMAKE_MAKE_PROGRAM=%ANDROID_NDK_ROOT%\prebuilt\windows-x86_64\bin\make.exe
+cmake $SOURCE_DIR -G "Unix Makefiles" -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DANDROID_ABI=arm64-v8a -DCMAKE_BUILD_TYPE=Release -DANDROID_STL=c++_static -DANDROID_PLATFORM=android-24 -DCMAKE_SYSTEM_NAME=Android -DANDROID_TOOLCHAIN=clang -DANDROID_ARM_MODE=arm -DCMAKE_MAKE_PROGRAM=$ANDROID_NDK_HOME/prebuilt/linux-x86_64/bin/make -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK_HOME/build/cmake/android.toolchain.cmake
+# If on Windows will be -DCMAKE_MAKE_PROGRAM=%ANDROID_NDK_HOME%\prebuilt\windows-x86_64\bin\make.exe
 # -G is needed for building on Windows
 # -DANDROID_ABI can also be armeabi-v7a for 32 bit
 ```
@@ -421,6 +429,77 @@
 In practice, `ShCompile()` takes shader strings, default version, and
 warning/error and other options for controlling compilation.
 
+### C Functional Interface (new)
+
+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)
+{
+    const glslang_input_t input = {
+        .language = GLSLANG_SOURCE_GLSL,
+        .stage = stage,
+        .client = GLSLANG_CLIENT_VULKAN,
+        .client_version = GLSLANG_TARGET_VULKAN_1_2,
+        .target_language = GLSLANG_TARGET_SPV,
+        .target_language_version = GLSLANG_TARGET_SPV_1_5,
+        .code = shaderSource,
+        .default_version = 100,
+        .default_profile = GLSLANG_NO_PROFILE,
+        .force_default_version_and_profile = false,
+        .forward_compatible = false,
+        .messages = GLSLANG_MSG_DEFAULT_BIT,
+        .resource = reinterpret_cast<const glslang_resource_t*>(&glslang::DefaultTBuiltInResource),
+    };
+
+    glslang_shader_t* shader = glslang_shader_create(&input);
+
+    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>();
+    }
+
+    if (!glslang_shader_parse(shader, &input)) {
+        printf("GLSL parsing 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", glslang_shader_get_preprocessed_code(shader));
+        glslang_shader_delete(shader);
+        return std::vector<uint32_t>();
+    }
+
+    glslang_program_t* program = glslang_program_create();
+    glslang_program_add_shader(program, shader);
+
+    if (!glslang_program_link(program, GLSLANG_MSG_SPV_RULES_BIT | GLSLANG_MSG_VULKAN_RULES_BIT)) {
+        printf("GLSL linking failed %s\n", fileName);
+        printf("%s\n", glslang_program_get_info_log(program));
+        printf("%s\n", glslang_program_get_info_debug_log(program));
+        glslang_program_delete(program);
+        glslang_shader_delete(shader);
+        return std::vector<uint32_t>();
+    }
+
+    glslang_program_SPIRV_generate(program, stage);
+
+    std::vector<uint32_t> outShaderModule(glslang_program_SPIRV_get_size(program));
+    glslang_program_SPIRV_get(program, outShaderModule.data());
+
+    const char* spirv_messages = glslang_program_SPIRV_get_messages(program);
+    if (spirv_messages)
+        printf("(%s) %s\b", fileName, spirv_messages);
+
+    glslang_program_delete(program);
+    glslang_shader_delete(shader);
+
+    return outShaderModule;
+}
+```
+
 ## Basic Internal Operation
 
 * Initial lexical analysis is done by the preprocessor in
diff --git a/SPIRV/CInterface/spirv_c_interface.cpp b/SPIRV/CInterface/spirv_c_interface.cpp
index a0790f4..d56ad46 100644
--- a/SPIRV/CInterface/spirv_c_interface.cpp
+++ b/SPIRV/CInterface/spirv_c_interface.cpp
@@ -36,6 +36,8 @@
 #include "SPIRV/Logger.h"
 #include "SPIRV/SpvTools.h"
 
+static_assert(sizeof(glslang_spv_options_t) == sizeof(glslang::SpvOptions), "");
+
 typedef struct glslang_program_s {
     glslang::TProgram* program;
     std::vector<unsigned int> spirv;
@@ -57,22 +59,22 @@
         return EShLangFragment;
     case GLSLANG_STAGE_COMPUTE:
         return EShLangCompute;
-    case GLSLANG_STAGE_RAYGEN_NV:
+    case GLSLANG_STAGE_RAYGEN:
         return EShLangRayGen;
-    case GLSLANG_STAGE_INTERSECT_NV:
+    case GLSLANG_STAGE_INTERSECT:
         return EShLangIntersect;
-    case GLSLANG_STAGE_ANYHIT_NV:
+    case GLSLANG_STAGE_ANYHIT:
         return EShLangAnyHit;
-    case GLSLANG_STAGE_CLOSESTHIT_NV:
+    case GLSLANG_STAGE_CLOSESTHIT:
         return EShLangClosestHit;
-    case GLSLANG_STAGE_MISS_NV:
+    case GLSLANG_STAGE_MISS:
         return EShLangMiss;
-    case GLSLANG_STAGE_CALLABLE_NV:
+    case GLSLANG_STAGE_CALLABLE:
         return EShLangCallable;
-    case GLSLANG_STAGE_TASK_NV:
-        return EShLangTaskNV;
-    case GLSLANG_STAGE_MESH_NV:
-        return EShLangMeshNV;
+    case GLSLANG_STAGE_TASK:
+        return EShLangTask;
+    case GLSLANG_STAGE_MESH:
+        return EShLangMesh;
     default:
         break;
     }
@@ -81,13 +83,25 @@
 
 GLSLANG_EXPORT void glslang_program_SPIRV_generate(glslang_program_t* program, glslang_stage_t stage)
 {
+    glslang_spv_options_t spv_options;
+    spv_options.generate_debug_info = false;
+    spv_options.strip_debug_info = false;
+    spv_options.emit_nonsemantic_shader_debug_info = false;
+    spv_options.emit_nonsemantic_shader_debug_source = false;
+    spv_options.disable_optimizer = true;
+    spv_options.optimize_size = false;
+    spv_options.disassemble = false;
+    spv_options.validate = true;
+
+    glslang_program_SPIRV_generate_with_options(program, stage, &spv_options);
+}
+
+GLSLANG_EXPORT void glslang_program_SPIRV_generate_with_options(glslang_program_t* program, glslang_stage_t stage, glslang_spv_options_t* spv_options) {
     spv::SpvBuildLogger logger;
-    glslang::SpvOptions spvOptions;
-    spvOptions.validate = true;
 
     const glslang::TIntermediate* intermediate = program->program->getIntermediate(c_shader_stage(stage));
 
-    glslang::GlslangToSpv(*intermediate, program->spirv, &logger, &spvOptions);
+    glslang::GlslangToSpv(*intermediate, program->spirv, &logger, reinterpret_cast<glslang::SpvOptions*>(spv_options));
 
     program->loggerMessages = logger.getAllMessages();
 }
diff --git a/SPIRV/CMakeLists.txt b/SPIRV/CMakeLists.txt
index 22f767d..2408e4c 100644
--- a/SPIRV/CMakeLists.txt
+++ b/SPIRV/CMakeLists.txt
@@ -62,7 +62,8 @@
     disassemble.h
     GLSL.ext.AMD.h
     GLSL.ext.NV.h
-    NonSemanticDebugPrintf.h)
+    NonSemanticDebugPrintf.h
+    NonSemanticShaderDebugInfo100.h)
 
 set(SPVREMAP_HEADERS
     SPVRemapper.h
@@ -109,30 +110,36 @@
 endif()
 
 if(ENABLE_GLSLANG_INSTALL)
-    if(BUILD_SHARED_LIBS)
-        if (ENABLE_SPVREMAPPER)
-            install(TARGETS SPVRemapper EXPORT SPVRemapperTargets
-                    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-                    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
-        endif()
-        install(TARGETS SPIRV EXPORT SPIRVTargets
-                ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-                LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-                RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-    else()
-        if (ENABLE_SPVREMAPPER)
-            install(TARGETS SPVRemapper EXPORT SPVRemapperTargets
-                    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-        endif()
-        install(TARGETS SPIRV EXPORT SPIRVTargets
-                ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-    endif()
-
     if (ENABLE_SPVREMAPPER)
-        install(EXPORT SPVRemapperTargets DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
+        install(TARGETS SPVRemapper EXPORT glslang-targets)
     endif()
 
-    install(EXPORT SPIRVTargets DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
+    install(TARGETS SPIRV EXPORT glslang-targets)
+
+    # Backward compatibility
+    if (ENABLE_SPVREMAPPER)
+        file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/SPVRemapperTargets.cmake" "
+            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\")
+            endif()
+
+            add_library(SPVRemapper ALIAS glslang::SPVRemapper)
+        ")
+        install(FILES "${CMAKE_CURRENT_BINARY_DIR}/SPVRemapperTargets.cmake" DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
+    endif()
+
+    file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/SPIRVTargets.cmake" "
+        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\")
+        endif()
+
+        add_library(SPIRV ALIAS glslang::SPIRV)
+    ")
+    install(FILES "${CMAKE_CURRENT_BINARY_DIR}/SPIRVTargets.cmake" DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
 
     install(FILES ${HEADERS} ${SPVREMAP_HEADERS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/glslang/SPIRV/)
 endif()
diff --git a/SPIRV/GLSL.ext.EXT.h b/SPIRV/GLSL.ext.EXT.h
index f48f130..a247b4c 100644
--- a/SPIRV/GLSL.ext.EXT.h
+++ b/SPIRV/GLSL.ext.EXT.h
@@ -39,5 +39,6 @@
 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_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 5eb3e94..d5c670f 100644
--- a/SPIRV/GLSL.ext.KHR.h
+++ b/SPIRV/GLSL.ext.KHR.h
@@ -29,7 +29,7 @@
 #define GLSLextKHR_H
 
 static const int GLSLextKHRVersion = 100;
-static const int GLSLextKHRRevision = 2;
+static const int GLSLextKHRRevision = 3;
 
 static const char* const E_SPV_KHR_shader_ballot                = "SPV_KHR_shader_ballot";
 static const char* const E_SPV_KHR_subgroup_vote                = "SPV_KHR_subgroup_vote";
@@ -52,5 +52,7 @@
 static const char* const E_SPV_KHR_terminate_invocation         = "SPV_KHR_terminate_invocation";
 static const char* const E_SPV_KHR_workgroup_memory_explicit_layout = "SPV_KHR_workgroup_memory_explicit_layout";
 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";
 
 #endif  // #ifndef GLSLextKHR_H
diff --git a/SPIRV/GlslangToSpv.cpp b/SPIRV/GlslangToSpv.cpp
index 43aba9c..ccb4602 100644
--- a/SPIRV/GlslangToSpv.cpp
+++ b/SPIRV/GlslangToSpv.cpp
@@ -260,6 +260,7 @@
     std::unordered_map<std::string, spv::Id> extBuiltinMap;
 
     std::unordered_map<long long, spv::Id> symbolValues;
+    std::unordered_map<uint32_t, spv::Id> builtInVariableIds;
     std::unordered_set<long long> rValueParameters;  // set of formal function parameters passed as rValues,
                                                // rather than a pointer
     std::unordered_map<std::string, spv::Function*> functionMap;
@@ -279,6 +280,9 @@
 
     // 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;
 };
 
 //
@@ -314,7 +318,7 @@
 }
 
 // Translate glslang language (stage) to SPIR-V execution model.
-spv::ExecutionModel TranslateExecutionModel(EShLanguage stage)
+spv::ExecutionModel TranslateExecutionModel(EShLanguage stage, bool isMeshShaderEXT = false)
 {
     switch (stage) {
     case EShLangVertex:           return spv::ExecutionModelVertex;
@@ -330,8 +334,8 @@
     case EShLangClosestHit:       return spv::ExecutionModelClosestHitKHR;
     case EShLangMiss:             return spv::ExecutionModelMissKHR;
     case EShLangCallable:         return spv::ExecutionModelCallableKHR;
-    case EShLangTaskNV:           return spv::ExecutionModelTaskNV;
-    case EShLangMeshNV:           return spv::ExecutionModelMeshNV;
+    case EShLangTask:             return (isMeshShaderEXT)? spv::ExecutionModelTaskEXT : spv::ExecutionModelTaskNV;
+    case EShLangMesh:             return (isMeshShaderEXT)? spv::ExecutionModelMeshEXT: spv::ExecutionModelMeshNV;
 #endif
     default:
         assert(0);
@@ -762,7 +766,7 @@
         return spv::BuiltInSampleMask;
 
     case glslang::EbvLayer:
-        if (glslangIntermediate->getStage() == EShLangMeshNV) {
+        if (glslangIntermediate->getStage() == EShLangMesh) {
             return spv::BuiltInLayer;
         }
         if (glslangIntermediate->getStage() == EShLangGeometry ||
@@ -1007,6 +1011,8 @@
         return spv::BuiltInRayTminKHR;
     case glslang::EbvRayTmax:
         return spv::BuiltInRayTmaxKHR;
+    case glslang::EbvCullMask:
+        return spv::BuiltInCullMaskKHR;
     case glslang::EbvInstanceCustomIndex:
         return spv::BuiltInInstanceCustomIndexKHR;
     case glslang::EbvHitT:
@@ -1048,6 +1054,15 @@
         builder.addCapability(spv::CapabilityFragmentBarycentricNV);
         return spv::BuiltInBaryCoordNoPerspNV;
 
+    case glslang::EbvBaryCoordEXT:
+        builder.addExtension(spv::E_SPV_KHR_fragment_shader_barycentric);
+        builder.addCapability(spv::CapabilityFragmentBarycentricKHR);
+        return spv::BuiltInBaryCoordKHR;
+    case glslang::EbvBaryCoordNoPerspEXT:
+        builder.addExtension(spv::E_SPV_KHR_fragment_shader_barycentric);
+        builder.addCapability(spv::CapabilityFragmentBarycentricKHR);
+        return spv::BuiltInBaryCoordNoPerspKHR;
+
     // mesh shaders
     case glslang::EbvTaskCountNV:
         return spv::BuiltInTaskCountNV;
@@ -1066,6 +1081,16 @@
     case glslang::EbvMeshViewIndicesNV:
         return spv::BuiltInMeshViewIndicesNV;
 
+    // SPV_EXT_mesh_shader
+    case glslang::EbvPrimitivePointIndicesEXT:
+        return spv::BuiltInPrimitivePointIndicesEXT;
+    case glslang::EbvPrimitiveLineIndicesEXT:
+        return spv::BuiltInPrimitiveLineIndicesEXT;
+    case glslang::EbvPrimitiveTriangleIndicesEXT:
+        return spv::BuiltInPrimitiveTriangleIndicesEXT;
+    case glslang::EbvCullPrimitiveEXT:
+        return spv::BuiltInCullPrimitiveEXT;
+
     // sm builtins
     case glslang::EbvWarpsPerSM:
         builder.addExtension(spv::E_SPV_NV_shader_sm_builtins);
@@ -1256,8 +1281,10 @@
     if (type.getBasicType() == glslang::EbtRayQuery)
         return spv::StorageClassPrivate;
 #ifndef GLSLANG_WEB
-    if (type.getQualifier().isSpirvByReference())
-        return spv::StorageClassFunction;
+    if (type.getQualifier().isSpirvByReference()) {
+        if (type.getQualifier().isParamInput() || type.getQualifier().isParamOutput())
+            return spv::StorageClassFunction;
+    }
 #endif
     if (type.getQualifier().isPipeInput())
         return spv::StorageClassInput;
@@ -1307,6 +1334,7 @@
     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::EvqSpirvStorageClass: return static_cast<spv::StorageClass>(type.getQualifier().spirvStorageClass);
 #endif
     default:
@@ -1324,7 +1352,9 @@
     for (auto constant : constants) {
         if (constant->getBasicType() == glslang::EbtFloat) {
             float floatValue = static_cast<float>(constant->getConstArray()[0].getDConst());
-            unsigned literal = *reinterpret_cast<unsigned*>(&floatValue);
+            unsigned literal;
+            static_assert(sizeof(literal) == sizeof(floatValue), "sizeof(unsigned) != sizeof(float)");
+            memcpy(&literal, &floatValue, sizeof(literal));
             literals.push_back(literal);
         } else if (constant->getBasicType() == glslang::EbtInt) {
             unsigned literal = constant->getConstArray()[0].getIConst();
@@ -1450,6 +1480,8 @@
         child.perViewNV = true;
     if (parent.perTaskNV)
         child.perTaskNV = true;
+    if (parent.storage == glslang::EvqtaskPayloadSharedEXT)
+        child.storage = glslang::EvqtaskPayloadSharedEXT;
     if (parent.patch)
         child.patch = true;
     if (parent.sample)
@@ -1509,9 +1541,12 @@
         inEntryPoint(false), entryPointTerminated(false), linkageOnly(false),
         glslangIntermediate(glslangIntermediate),
         nanMinMaxClamp(glslangIntermediate->getNanMinMaxClamp()),
-        nonSemanticDebugPrintf(0)
+        nonSemanticDebugPrintf(0),
+        taskPayloadID(0)
 {
-    spv::ExecutionModel executionModel = TranslateExecutionModel(glslangIntermediate->getStage());
+    bool isMeshShaderExt = (glslangIntermediate->getRequestedExtensions().find(glslang::E_GL_EXT_mesh_shader) !=
+                            glslangIntermediate->getRequestedExtensions().end());
+    spv::ExecutionModel executionModel = TranslateExecutionModel(glslangIntermediate->getStage(), isMeshShaderExt);
 
     builder.clearAccessChain();
     builder.setSource(TranslateSourceLanguage(glslangIntermediate->getSource(), glslangIntermediate->getProfile()),
@@ -1543,6 +1578,10 @@
         for (auto iItr = include_txt.begin(); iItr != include_txt.end(); ++iItr)
             builder.addInclude(iItr->first, iItr->second);
     }
+
+    builder.setEmitNonSemanticShaderDebugInfo(options.emitNonSemanticShaderDebugInfo);
+    builder.setEmitNonSemanticShaderDebugSource(options.emitNonSemanticShaderDebugSource);
+
     stdBuiltins = builder.import("GLSL.std.450");
 
     spv::AddressingModel addressingModel = spv::AddressingModelLogical;
@@ -1609,6 +1648,12 @@
         if (glslangIntermediate->getEarlyFragmentTests())
             builder.addExecutionMode(shaderEntry, spv::ExecutionModeEarlyFragmentTests);
 
+        if (glslangIntermediate->getEarlyAndLateFragmentTestsAMD())
+        {
+            builder.addExecutionMode(shaderEntry, spv::ExecutionModeEarlyAndLateFragmentTestsAMD);
+            builder.addExtension(spv::E_SPV_AMD_shader_early_and_late_fragment_tests);
+        }
+
         if (glslangIntermediate->getPostDepthCoverage()) {
             builder.addCapability(spv::CapabilitySampleMaskPostDepthCoverage);
             builder.addExecutionMode(shaderEntry, spv::ExecutionModePostDepthCoverage);
@@ -1618,6 +1663,9 @@
         if (glslangIntermediate->isDepthReplacing())
             builder.addExecutionMode(shaderEntry, spv::ExecutionModeDepthReplacing);
 
+        if (glslangIntermediate->isStencilReplacing())
+            builder.addExecutionMode(shaderEntry, spv::ExecutionModeStencilRefReplacingEXT);
+
 #ifndef GLSLANG_WEB
 
         switch(glslangIntermediate->getDepth()) {
@@ -1626,6 +1674,20 @@
         case glslang::EldUnchanged: mode = spv::ExecutionModeDepthUnchanged; break;
         default:                    mode = spv::ExecutionModeMax;            break;
         }
+
+        if (mode != spv::ExecutionModeMax)
+            builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
+
+        switch (glslangIntermediate->getStencil()) {
+        case glslang::ElsRefUnchangedFrontAMD:  mode = spv::ExecutionModeStencilRefUnchangedFrontAMD; break;
+        case glslang::ElsRefGreaterFrontAMD:    mode = spv::ExecutionModeStencilRefGreaterFrontAMD;   break;
+        case glslang::ElsRefLessFrontAMD:       mode = spv::ExecutionModeStencilRefLessFrontAMD;      break;
+        case glslang::ElsRefUnchangedBackAMD:   mode = spv::ExecutionModeStencilRefUnchangedBackAMD;  break;
+        case glslang::ElsRefGreaterBackAMD:     mode = spv::ExecutionModeStencilRefGreaterBackAMD;    break;
+        case glslang::ElsRefLessBackAMD:        mode = spv::ExecutionModeStencilRefLessBackAMD;       break;
+        default:                       mode = spv::ExecutionModeMax;                         break;
+        }
+
         if (mode != spv::ExecutionModeMax)
             builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
         switch (glslangIntermediate->getInterlockOrdering()) {
@@ -1662,9 +1724,22 @@
 
     case EShLangCompute:
         builder.addCapability(spv::CapabilityShader);
-        builder.addExecutionMode(shaderEntry, spv::ExecutionModeLocalSize, glslangIntermediate->getLocalSize(0),
-                                                                           glslangIntermediate->getLocalSize(1),
-                                                                           glslangIntermediate->getLocalSize(2));
+        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));
+            }
+          }
+          builder.addExecutionModeId(shaderEntry, spv::ExecutionModeLocalSizeId, dimConstId);
+        } else {
+          builder.addExecutionMode(shaderEntry, spv::ExecutionModeLocalSize, glslangIntermediate->getLocalSize(0),
+                                                                             glslangIntermediate->getLocalSize(1),
+                                                                             glslangIntermediate->getLocalSize(2));
+        }
         if (glslangIntermediate->getLayoutDerivativeModeNone() == glslang::LayoutDerivativeGroupQuads) {
             builder.addCapability(spv::CapabilityComputeDerivativeGroupQuadsNV);
             builder.addExecutionMode(shaderEntry, spv::ExecutionModeDerivativeGroupQuadsNV);
@@ -1751,7 +1826,7 @@
     case EShLangAnyHit:
     case EShLangClosestHit:
     case EShLangMiss:
-    case EShLangCallable: 
+    case EShLangCallable:
     {
         auto& extensions = glslangIntermediate->getRequestedExtensions();
         if (extensions.find("GL_NV_ray_tracing") == extensions.end()) {
@@ -1762,16 +1837,41 @@
             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");
+		}
+	}
         break;
     }
-    case EShLangTaskNV:
-    case EShLangMeshNV:
-        builder.addCapability(spv::CapabilityMeshShadingNV);
-        builder.addExtension(spv::E_SPV_NV_mesh_shader);
-        builder.addExecutionMode(shaderEntry, spv::ExecutionModeLocalSize, glslangIntermediate->getLocalSize(0),
-                                                                           glslangIntermediate->getLocalSize(1),
-                                                                           glslangIntermediate->getLocalSize(2));
-        if (glslangIntermediate->getStage() == EShLangMeshNV) {
+    case EShLangTask:
+    case EShLangMesh:
+        if(isMeshShaderExt) {
+            builder.addCapability(spv::CapabilityMeshShadingEXT);
+            builder.addExtension(spv::E_SPV_EXT_mesh_shader);
+        } else {
+            builder.addCapability(spv::CapabilityMeshShadingNV);
+            builder.addExtension(spv::E_SPV_NV_mesh_shader);
+        }
+        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));
+                }
+            }
+            builder.addExecutionModeId(shaderEntry, spv::ExecutionModeLocalSizeId, dimConstId);
+        } else {
+            builder.addExecutionMode(shaderEntry, spv::ExecutionModeLocalSize, glslangIntermediate->getLocalSize(0),
+                                                                               glslangIntermediate->getLocalSize(1),
+                                                                               glslangIntermediate->getLocalSize(2));
+        }
+        if (glslangIntermediate->getStage() == EShLangMesh) {
             builder.addExecutionMode(shaderEntry, spv::ExecutionModeOutputVertices,
                 glslangIntermediate->getVertices());
             builder.addExecutionMode(shaderEntry, spv::ExecutionModeOutputPrimitivesNV,
@@ -1890,7 +1990,6 @@
 
     if (symbol->getType().getQualifier().isSpecConstant())
         spec_constant_op_mode_setter.turnOnSpecConstantOpMode();
-
 #ifdef ENABLE_HLSL
     // Skip symbol handling if it is string-typed
     if (symbol->getBasicType() == glslang::EbtString)
@@ -1901,6 +2000,9 @@
     // Formal function parameters were mapped during makeFunctions().
     spv::Id id = getSymbolId(symbol);
 
+    if (symbol->getType().getQualifier().isTaskPayload())
+        taskPayloadID = id; // cache the taskPayloadID to be used it as operand for OpEmitMeshTasksEXT
+
     if (builder.isPointer(id)) {
         if (!symbol->getType().getQualifier().isParamInput() &&
             !symbol->getType().getQualifier().isParamOutput()) {
@@ -2428,6 +2530,14 @@
         return false;
     }
 
+    // Force variable declaration - Debug Mode Only
+    if (node->getOp() == glslang::EOpDeclare) {
+        builder.clearAccessChain();
+        node->getOperand()->traverse(this);
+        builder.clearAccessChain();
+        return false;
+    }
+
     // Start by evaluating the operand
 
     // Does it need a swizzle inversion?  If so, evaluation is inverted;
@@ -2444,7 +2554,7 @@
         operandNode = node->getOperand()->getAsBinaryNode()->getLeft();
     else
         operandNode = node->getOperand();
-    
+
     operandNode->traverse(this);
 
     spv::Id operand = spv::NoResult;
@@ -2688,32 +2798,38 @@
     spv::Decoration precision = TranslatePrecisionDecoration(node->getOperationPrecision());
 
     switch (node->getOp()) {
+    case glslang::EOpScope:
     case glslang::EOpSequence:
     {
-        if (preVisit)
+        if (visit == glslang::EvPreVisit) {
             ++sequenceDepth;
-        else
+            if (sequenceDepth == 1) {
+                // If this is the parent node of all the functions, we want to see them
+                // early, so all call points have actual SPIR-V functions to reference.
+                // 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());
+
+                //Pre process linker objects for ray tracing stages
+                if (glslangIntermediate->isRayTracingStage())
+                  collectRayTracingLinkerObjects();
+
+                // Initializers are done, don't want to visit again, but functions and link objects need to be processed,
+                // so do them manually.
+                visitFunctions(node->getAsAggregate()->getSequence());
+
+                return false;
+            } else {
+                if (node->getOp() == glslang::EOpScope)
+                    builder.enterScope(0);
+            }
+        } else {
+            if (sequenceDepth > 1 && node->getOp() == glslang::EOpScope)
+                builder.leaveScope();
             --sequenceDepth;
-
-        if (sequenceDepth == 1) {
-            // If this is the parent node of all the functions, we want to see them
-            // early, so all call points have actual SPIR-V functions to reference.
-            // 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());
-
-            //Pre process linker objects for ray tracing stages
-            if (glslangIntermediate->isRayTracingStage())
-                collectRayTracingLinkerObjects();
-
-            // Initializers are done, don't want to visit again, but functions and link objects need to be processed,
-            // so do them manually.
-            visitFunctions(node->getAsAggregate()->getSequence());
-
-            return false;
         }
 
         return true;
@@ -2742,10 +2858,17 @@
             if (isShaderEntryPoint(node)) {
                 inEntryPoint = true;
                 builder.setBuildPoint(shaderEntry->getLastBlock());
+                builder.enterFunction(shaderEntry);
                 currentFunction = shaderEntry;
             } else {
                 handleFunctionEntry(node);
             }
+            if (options.generateDebugInfo) {
+                const auto& loc = node->getLoc();
+                const char* sourceFileName = loc.getFilename();
+                spv::Id sourceFileId = sourceFileName ? builder.getStringId(sourceFileName) : builder.getSourceFile();
+                currentFunction->setDebugLineInfo(sourceFileId, loc.line, loc.column);
+            }
         } else {
             if (inEntryPoint)
                 entryPointTerminated = true;
@@ -2885,9 +3008,17 @@
         std::vector<spv::Id> arguments;
         translateArguments(*node, arguments, lvalueCoherentFlags);
         spv::Id constructed;
-        if (node->getOp() == glslang::EOpConstructTextureSampler)
-            constructed = builder.createOp(spv::OpSampledImage, resultType(), arguments);
-        else if (node->getOp() == glslang::EOpConstructStruct ||
+        if (node->getOp() == glslang::EOpConstructTextureSampler) {
+            const glslang::TType& texType = node->getSequence()[0]->getAsTyped()->getType();
+            if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6 &&
+                texType.getSampler().isBuffer()) {
+                // SamplerBuffer is not supported in spirv1.6 so
+                // `samplerBuffer(textureBuffer, sampler)` is a no-op
+                // and textureBuffer is the result going forward
+                constructed = arguments[0];
+            } else
+                constructed = builder.createOp(spv::OpSampledImage, resultType(), arguments);
+        } else if (node->getOp() == glslang::EOpConstructStruct ||
                  node->getOp() == glslang::EOpConstructCooperativeMatrix ||
                  node->getType().isArray()) {
             std::vector<spv::Id> constituents;
@@ -3027,6 +3158,8 @@
     case glslang::EOpExecuteCallableNV:
     case glslang::EOpExecuteCallableKHR:
     case glslang::EOpWritePackedPrimitiveIndices4x8NV:
+    case glslang::EOpEmitMeshTasksEXT:
+    case glslang::EOpSetMeshOutputsEXT:
         noReturnValue = true;
         break;
     case glslang::EOpRayQueryInitialize:
@@ -3421,7 +3554,7 @@
             break;
         case 1:
             {
-                OpDecorations decorations = { precision, 
+                OpDecorations decorations = { precision,
                                               TranslateNoContractionDecoration(node->getType().getQualifier()),
                                               TranslateNonUniformDecoration(node->getType().getQualifier()) };
                 result = createUnaryOperation(
@@ -3543,7 +3676,7 @@
             // smear condition to vector, if necessary (AST is always scalar)
             // Before 1.4, smear like for mix(), starting with 1.4, keep it scalar
             if (glslangIntermediate->getSpv().spv < glslang::EShTargetSpv_1_4 && builder.isVector(trueValue)) {
-                condition = builder.smearScalar(spv::NoPrecision, condition, 
+                condition = builder.smearScalar(spv::NoPrecision, condition,
                                                 builder.makeVectorType(builder.makeBoolType(),
                                                                        builder.getNumComponents(trueValue)));
             }
@@ -3714,8 +3847,8 @@
     // by a block-ending branch.  But we don't want to put any other body/test
     // instructions in it, since the body/test may have arbitrary instructions,
     // including merges of its own.
-    builder.setLine(node->getLoc().line, node->getLoc().getFilename());
     builder.setBuildPoint(&blocks.head);
+    builder.setLine(node->getLoc().line, node->getLoc().getFilename());
     builder.createLoopMerge(&blocks.merge, &blocks.continue_target, control, operands);
     if (node->testFirst() && node->getTest()) {
         spv::Block& test = builder.makeNewBlock();
@@ -3777,7 +3910,16 @@
 
     switch (node->getFlowOp()) {
     case glslang::EOpKill:
-        builder.makeStatementTerminator(spv::OpKill, "post-discard");
+        if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6) {
+            if (glslangIntermediate->getSource() == glslang::EShSourceHlsl) {
+              builder.addCapability(spv::CapabilityDemoteToHelperInvocation);
+              builder.createNoResultOp(spv::OpDemoteToHelperInvocationEXT);
+            } else {
+                builder.makeStatementTerminator(spv::OpTerminateInvocation, "post-terminate-invocation");
+            }
+        } else {
+            builder.makeStatementTerminator(spv::OpKill, "post-discard");
+        }
         break;
     case glslang::EOpTerminateInvocation:
         builder.addExtension(spv::E_SPV_KHR_terminate_invocation);
@@ -3925,7 +4067,7 @@
         initializer = builder.makeNullConstant(spvType);
     }
 
-    return builder.createVariable(spv::NoPrecision, storageClass, spvType, name, initializer);
+    return builder.createVariable(spv::NoPrecision, storageClass, spvType, name, initializer, false);
 }
 
 // Return type Id of the sampled type.
@@ -4013,7 +4155,7 @@
         if (explicitLayout != glslang::ElpNone)
             spvType = builder.makeUintType(32);
         else
-            spvType = builder.makeBoolType();
+            spvType = builder.makeBoolType(false);
         break;
     case glslang::EbtInt:
         spvType = builder.makeIntType(32);
@@ -4113,8 +4255,10 @@
                 spvType = builder.makeImageType(getSampledType(sampler), TranslateDimensionality(sampler),
                                                 sampler.isShadow(), sampler.isArrayed(), sampler.isMultiSample(),
                                                 sampler.isImageClass() ? 2 : 1, TranslateImageFormat(type));
-                if (sampler.isCombined()) {
-                    // already has both image and sampler, make the combined type
+                if (sampler.isCombined() &&
+                    (!sampler.isBuffer() || glslangIntermediate->getSpv().spv < glslang::EShTargetSpv_1_6)) {
+                    // Already has both image and sampler, make the combined type. Only combine sampler to
+                    // buffer if before SPIR-V 1.6.
                     spvType = builder.makeSampledImageType(spvType);
                 }
             }
@@ -4148,23 +4292,25 @@
         const auto& spirvType = type.getSpirvType();
         const auto& spirvInst = spirvType.spirvInst;
 
-        std::vector<spv::Id> operands;
+        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 = *reinterpret_cast<unsigned*>(&floatValue);
-                    operands.push_back(literal);
+                    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(literal);
+                    operands.push_back({false, literal});
                 } else if (typeParam.constant->getBasicType() == glslang::EbtUint) {
                     unsigned literal = typeParam.constant->getConstArray()[0].getUConst();
-                    operands.push_back(literal);
+                    operands.push_back({false, literal});
                 } else if (typeParam.constant->getBasicType() == glslang::EbtBool) {
                     unsigned literal = typeParam.constant->getConstArray()[0].getBConst();
-                    operands.push_back(literal);
+                    operands.push_back({false, literal});
                 } else if (typeParam.constant->getBasicType() == glslang::EbtString) {
                     auto str = typeParam.constant->getConstArray()[0].getSConst()->c_str();
                     unsigned literal = 0;
@@ -4176,7 +4322,7 @@
                         *(literalPtr++) = ch;
                         ++charCount;
                         if (charCount == 4) {
-                            operands.push_back(literal);
+                            operands.push_back({false, literal});
                             literalPtr = reinterpret_cast<char*>(&literal);
                             charCount = 0;
                         }
@@ -4186,20 +4332,17 @@
                     if (charCount > 0) {
                         for (; charCount < 4; ++charCount)
                             *(literalPtr++) = 0;
-                        operands.push_back(literal);
+                        operands.push_back({false, literal});
                     }
                 } else
                     assert(0); // Unexpected type
             } else
-                operands.push_back(createSpvConstant(*typeParam.constant));
+                operands.push_back({true, createSpvConstant(*typeParam.constant)});
         }
 
-        if (spirvInst.set == "")
-            spvType = builder.createOp(static_cast<spv::Op>(spirvInst.id), spv::NoType, operands);
-        else {
-            spvType = builder.createBuiltinCall(
-                spv::NoType, getExtBuiltins(spirvInst.set.c_str()), spirvInst.id, operands);
-        }
+        assert(spirvInst.set == ""); // Currently, couldn't be extended instructions.
+        spvType = builder.makeGenericType(static_cast<spv::Op>(spirvInst.id), operands);
+
         break;
     }
 #endif
@@ -4302,7 +4445,7 @@
         extensions.find("GL_NV_stereo_view_rendering") == extensions.end())
         return true;
 
-    if (glslangIntermediate->getStage() != EShLangMeshNV) {
+    if (glslangIntermediate->getStage() != EShLangMesh) {
         if (member.getFieldName() == "gl_ViewportMask" &&
             extensions.find("GL_NV_viewport_array2") == extensions.end())
             return true;
@@ -4332,14 +4475,14 @@
                           // except sometimes for blocks
     std::vector<std::pair<glslang::TType*, glslang::TQualifier> > deferredForwardPointers;
     for (int i = 0; i < (int)glslangMembers->size(); i++) {
-        glslang::TType& glslangMember = *(*glslangMembers)[i].type;
-        if (glslangMember.hiddenMember()) {
+        auto& glslangMember = (*glslangMembers)[i];
+        if (glslangMember.type->hiddenMember()) {
             ++memberDelta;
             if (type.getBasicType() == glslang::EbtBlock)
                 memberRemapper[glslangTypeToIdMap[glslangMembers]][i] = -1;
         } else {
             if (type.getBasicType() == glslang::EbtBlock) {
-                if (filterMember(glslangMember)) {
+                if (filterMember(*glslangMember.type)) {
                     memberDelta++;
                     memberRemapper[glslangTypeToIdMap[glslangMembers]][i] = -1;
                     continue;
@@ -4347,7 +4490,7 @@
                 memberRemapper[glslangTypeToIdMap[glslangMembers]][i] = i - memberDelta;
             }
             // modify just this child's view of the qualifier
-            glslang::TQualifier memberQualifier = glslangMember.getQualifier();
+            glslang::TQualifier memberQualifier = glslangMember.type->getQualifier();
             InheritQualifiers(memberQualifier, qualifier);
 
             // manually inherit location
@@ -4358,25 +4501,38 @@
             bool lastBufferBlockMember = qualifier.storage == glslang::EvqBuffer &&
                                          i == (int)glslangMembers->size() - 1;
 
-            // Make forward pointers for any pointer members, and create a list of members to
-            // convert to spirv types after creating the struct.
-            if (glslangMember.isReference()) {
-                if (forwardPointers.find(glslangMember.getReferentType()) == forwardPointers.end()) {
-                    deferredForwardPointers.push_back(std::make_pair(&glslangMember, memberQualifier));
-                }
-                spvMembers.push_back(
-                    convertGlslangToSpvType(glslangMember, explicitLayout, memberQualifier, lastBufferBlockMember,
-                        true));
-            } else {
-                spvMembers.push_back(
-                    convertGlslangToSpvType(glslangMember, explicitLayout, memberQualifier, lastBufferBlockMember,
-                        false));
+            // Make forward pointers for any pointer members.
+            if (glslangMember.type->isReference() &&
+                forwardPointers.find(glslangMember.type->getReferentType()) == forwardPointers.end()) {
+                deferredForwardPointers.push_back(std::make_pair(glslangMember.type, memberQualifier));
+            }
+
+            // Create the member type.
+            auto const spvMember = convertGlslangToSpvType(*glslangMember.type, explicitLayout, memberQualifier, lastBufferBlockMember,
+                glslangMember.type->isReference());
+            spvMembers.push_back(spvMember);
+
+            // Update the builder with the type's location so that we can create debug types for the structure members.
+            // There doesn't exist a "clean" entry point for this information to be passed along to the builder so, for now,
+            // it is stored in the builder and consumed during the construction of composite debug types.
+            // TODO: This probably warrants further investigation. This approach was decided to be the least ugly of the
+            // quick and dirty approaches that were tried.
+            // Advantages of this approach:
+            //  + Relatively clean. No direct calls into debug type system.
+            //  + Handles nested recursive structures.
+            // Disadvantages of this approach:
+            //  + Not as clean as desired. Traverser queries/sets persistent state. This is fragile.
+            //  + Table lookup during creation of composite debug types. This really shouldn't be necessary.
+            if(options.emitNonSemanticShaderDebugInfo) {
+                builder.debugTypeLocs[spvMember].name = glslangMember.type->getFieldName().c_str();
+                builder.debugTypeLocs[spvMember].line = glslangMember.loc.line;
+                builder.debugTypeLocs[spvMember].column = glslangMember.loc.column;
             }
         }
     }
 
     // Make the SPIR-V type
-    spv::Id spvType = builder.makeStructType(spvMembers, type.getTypeName().c_str());
+    spv::Id spvType = builder.makeStructType(spvMembers, type.getTypeName().c_str(), false);
     if (! HasNonLayoutQualifiers(type, qualifier))
         structMap[explicitLayout][qualifier.layoutMatrix][glslangMembers] = spvType;
 
@@ -4970,6 +5126,7 @@
         //   GLSL has copy-in/copy-out semantics.  They can be handled though with a pointer to a copy.
 
         std::vector<spv::Id> paramTypes;
+        std::vector<char const*> paramNames;
         std::vector<std::vector<spv::Decoration>> paramDecorations; // list of decorations per parameter
         glslang::TIntermSequence& parameters = glslFunction->getSequence()[0]->getAsAggregate()->getSequence();
 
@@ -4994,10 +5151,14 @@
             paramTypes.push_back(typeId);
         }
 
+        for (auto const parameter:parameters) {
+            paramNames.push_back(parameter->getAsSymbolNode()->getName().c_str());
+        }
+
         spv::Block* functionBlock;
         spv::Function *function = builder.makeFunctionEntry(TranslatePrecisionDecoration(glslFunction->getType()),
                                                             convertGlslangToSpvType(glslFunction->getType()),
-                                                            glslFunction->getName().c_str(), paramTypes,
+                                                            glslFunction->getName().c_str(), paramTypes, paramNames,
                                                             paramDecorations, &functionBlock);
         if (implicitThis)
             function->setImplicitThis();
@@ -5087,6 +5248,7 @@
     currentFunction = functionMap[node->getName().c_str()];
     spv::Block* functionBlock = currentFunction->getEntryBlock();
     builder.setBuildPoint(functionBlock);
+    builder.enterFunction(currentFunction);
 }
 
 void TGlslangToSpvTraverser::translateArguments(const glslang::TIntermAggregate& node, std::vector<spv::Id>& arguments,
@@ -5514,10 +5676,12 @@
             operands.push_back(sample);
 
             spv::Id resultTypeId;
+            glslang::TBasicType typeProxy = node->getBasicType();
             // imageAtomicStore has a void return type so base the pointer type on
             // the type of the value operand.
             if (node->getOp() == glslang::EOpImageAtomicStore) {
                 resultTypeId = builder.makePointer(spv::StorageClassImage, builder.getTypeId(*opIt));
+                typeProxy = node->getAsAggregate()->getSequence()[0]->getAsTyped()->getType().getSampler().type;
             } else {
                 resultTypeId = builder.makePointer(spv::StorageClassImage, resultType());
             }
@@ -5531,7 +5695,7 @@
             for (; opIt != arguments.end(); ++opIt)
                 operands.push_back(*opIt);
 
-            return createAtomicOperation(node->getOp(), precision, resultType(), operands, node->getBasicType(),
+            return createAtomicOperation(node->getOp(), precision, resultType(), operands, typeProxy,
                 lvalueCoherentFlags);
         }
     }
@@ -5735,10 +5899,10 @@
         assert(builder.isStructType(resultStructType));
 
         //resType (SPIR-V type) contains 6 elements:
-        //Member 0 must be a Boolean type scalar(LOD), 
-        //Member 1 must be a vector of integer type, whose Signedness operand is 0(anchor),  
-        //Member 2 must be a vector of integer type, whose Signedness operand is 0(offset), 
-        //Member 3 must be a vector of integer type, whose Signedness operand is 0(mask), 
+        //Member 0 must be a Boolean type scalar(LOD),
+        //Member 1 must be a vector of integer type, whose Signedness operand is 0(anchor),
+        //Member 2 must be a vector of integer type, whose Signedness operand is 0(offset),
+        //Member 3 must be a vector of integer type, whose Signedness operand is 0(mask),
         //Member 4 must be a scalar of integer type, whose Signedness operand is 0(lod),
         //Member 5 must be a scalar of integer type, whose Signedness operand is 0(granularity).
         std::vector<spv::Id> members;
@@ -5751,7 +5915,7 @@
         //call ImageFootprintNV
         spv::Id res = builder.createTextureCall(precision, resType, sparse, cracked.fetch, cracked.proj,
                                                 cracked.gather, noImplicitLod, params, signExtensionMask());
-        
+
         //copy resType (SPIR-V type) to resultStructType(OpenGL type)
         for (int i = 0; i < 5; i++) {
             builder.clearAccessChain();
@@ -5804,7 +5968,7 @@
     }
 #endif
 
-    std::vector<spv::Id> result( 1, 
+    std::vector<spv::Id> result( 1,
         builder.createTextureCall(precision, resultType(), sparse, cracked.fetch, cracked.proj, cracked.gather,
                                   noImplicitLod, params, signExtensionMask())
     );
@@ -7327,7 +7491,7 @@
     } else {
         scopeId = builder.makeUintConstant(spv::ScopeDevice);
     }
-    // semantics default to relaxed 
+    // semantics default to relaxed
     spv::Id semanticsId = builder.makeUintConstant(lvalueCoherentFlags.isVolatile() &&
         glslangIntermediate->usingVulkanMemoryModel() ?
                                                     spv::MemorySemanticsVolatileMask :
@@ -8431,6 +8595,15 @@
     case glslang::EOpWritePackedPrimitiveIndices4x8NV:
         builder.createNoResultOp(spv::OpWritePackedPrimitiveIndices4x8NV, operands);
         return 0;
+    case glslang::EOpEmitMeshTasksEXT:
+        if (taskPayloadID)
+            operands.push_back(taskPayloadID);
+        // As per SPV_EXT_mesh_shader make it a terminating instruction in the current block
+        builder.makeStatementTerminator(spv::OpEmitMeshTasksEXT, operands, "post-OpEmitMeshTasksEXT");
+        return 0;
+    case glslang::EOpSetMeshOutputsEXT:
+        builder.createNoResultOp(spv::OpSetMeshOutputsEXT, operands);
+        return 0;
     case glslang::EOpCooperativeMatrixMulAdd:
         opCode = spv::OpCooperativeMatrixMulAddNV;
         break;
@@ -8694,7 +8867,32 @@
     // it was not found, create it
     spv::BuiltIn builtIn = TranslateBuiltInDecoration(symbol->getQualifier().builtIn, false);
     auto forcedType = getForcedType(symbol->getQualifier().builtIn, symbol->getType());
+
+    // There are pairs of symbols that map to the same SPIR-V built-in:
+    // gl_ObjectToWorldEXT and gl_ObjectToWorld3x4EXT, and gl_WorldToObjectEXT
+    // and gl_WorldToObject3x4EXT. SPIR-V forbids having two OpVariables
+    // with the same BuiltIn in the same storage class, so we must re-use one.
+    const bool mayNeedToReuseBuiltIn =
+        builtIn == spv::BuiltInObjectToWorldKHR ||
+        builtIn == spv::BuiltInWorldToObjectKHR;
+
+    if (mayNeedToReuseBuiltIn) {
+        auto iter = builtInVariableIds.find(uint32_t(builtIn));
+        if (builtInVariableIds.end() != iter) {
+            id = iter->second;
+            symbolValues[symbol->getId()] = id;
+            if (forcedType.second != spv::NoType)
+                forceType[id] = forcedType.second;
+            return id;
+        }
+    }
+
     id = createSpvVariable(symbol, forcedType.first);
+
+    if (mayNeedToReuseBuiltIn) {
+        builtInVariableIds.insert({uint32_t(builtIn), id});
+    }
+
     symbolValues[symbol->getId()] = id;
     if (forcedType.second != spv::NoType)
         forceType[id] = forcedType.second;
@@ -8717,8 +8915,18 @@
             builder.addDecoration(id, spv::DecorationOffset, symbol->getQualifier().layoutOffset);
     }
 
-    if (symbol->getQualifier().hasLocation())
-        builder.addDecoration(id, spv::DecorationLocation, symbol->getQualifier().layoutLocation);
+    if (symbol->getQualifier().hasLocation()) {
+        if (!(glslangIntermediate->isRayTracingStage() && glslangIntermediate->IsRequestedExtension(glslang::E_GL_EXT_ray_tracing)
+              && (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.addDecoration(id, spv::DecorationLocation, symbol->getQualifier().layoutLocation);
+        }
+    }
+
     builder.addDecoration(id, TranslateInvariantDecoration(symbol->getType().getQualifier()));
     if (symbol->getQualifier().hasStream() && glslangIntermediate->isMultiStream()) {
         builder.addCapability(spv::CapabilityGeometryStreams);
@@ -8752,7 +8960,16 @@
 
     // add built-in variable decoration
     if (builtIn != spv::BuiltInMax) {
-        builder.addDecoration(id, spv::DecorationBuiltIn, (int)builtIn);
+        // WorkgroupSize deprecated in spirv1.6
+        if (glslangIntermediate->getSpv().spv < glslang::EShTargetSpv_1_6 ||
+            builtIn != spv::BuiltInWorkgroupSize)
+            builder.addDecoration(id, spv::DecorationBuiltIn, (int)builtIn);
+    }
+
+    // Add volatile decoration to HelperInvocation for spirv1.6 and beyond
+    if (builtIn == spv::BuiltInHelperInvocation &&
+        glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6) {
+        builder.addDecoration(id, spv::DecorationVolatile);
     }
 
 #ifndef GLSLANG_WEB
@@ -8804,6 +9021,12 @@
         builder.addExtension(spv::E_SPV_NV_fragment_shader_barycentric);
     }
 
+    if (symbol->getQualifier().pervertexEXT) {
+        builder.addDecoration(id, spv::DecorationPerVertexKHR);
+        builder.addCapability(spv::CapabilityFragmentBarycentricKHR);
+        builder.addExtension(spv::E_SPV_KHR_fragment_shader_barycentric);
+    }
+
     if (glslangIntermediate->getHlslFunctionality1() && symbol->getType().getQualifier().semanticName != nullptr) {
         builder.addExtension("SPV_GOOGLE_hlsl_functionality1");
         builder.addDecoration(id, (spv::Decoration)spv::DecorationHlslSemanticGOOGLE,
@@ -8865,13 +9088,21 @@
 // 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)
 {
+    bool isMeshShaderExt = (glslangIntermediate->getRequestedExtensions().find(glslang::E_GL_EXT_mesh_shader) !=
+                            glslangIntermediate->getRequestedExtensions().end());
+
     if (member >= 0) {
         if (qualifier.perPrimitiveNV) {
             // Need to add capability/extension for fragment shader.
             // Mesh shader already adds this by default.
             if (glslangIntermediate->getStage() == EShLangFragment) {
-                builder.addCapability(spv::CapabilityMeshShadingNV);
-                builder.addExtension(spv::E_SPV_NV_mesh_shader);
+                if(isMeshShaderExt) {
+                    builder.addCapability(spv::CapabilityMeshShadingEXT);
+                    builder.addExtension(spv::E_SPV_EXT_mesh_shader);
+                } else {
+                    builder.addCapability(spv::CapabilityMeshShadingNV);
+                    builder.addExtension(spv::E_SPV_NV_mesh_shader);
+                }
             }
             builder.addMemberDecoration(id, (unsigned)member, spv::DecorationPerPrimitiveNV);
         }
@@ -8884,8 +9115,13 @@
             // Need to add capability/extension for fragment shader.
             // Mesh shader already adds this by default.
             if (glslangIntermediate->getStage() == EShLangFragment) {
-                builder.addCapability(spv::CapabilityMeshShadingNV);
-                builder.addExtension(spv::E_SPV_NV_mesh_shader);
+                if(isMeshShaderExt) {
+                    builder.addCapability(spv::CapabilityMeshShadingEXT);
+                    builder.addExtension(spv::E_SPV_EXT_mesh_shader);
+                } else {
+                    builder.addCapability(spv::CapabilityMeshShadingNV);
+                    builder.addExtension(spv::E_SPV_NV_mesh_shader);
+                }
             }
             builder.addDecoration(id, spv::DecorationPerPrimitiveNV);
         }
@@ -9025,15 +9261,19 @@
                 break;
 #ifndef GLSLANG_WEB
             case glslang::EbtInt8:
+                builder.addCapability(spv::CapabilityInt8);
                 spvConsts.push_back(builder.makeInt8Constant(zero ? 0 : consts[nextConst].getI8Const()));
                 break;
             case glslang::EbtUint8:
+                builder.addCapability(spv::CapabilityInt8);
                 spvConsts.push_back(builder.makeUint8Constant(zero ? 0 : consts[nextConst].getU8Const()));
                 break;
             case glslang::EbtInt16:
+                builder.addCapability(spv::CapabilityInt16);
                 spvConsts.push_back(builder.makeInt16Constant(zero ? 0 : consts[nextConst].getI16Const()));
                 break;
             case glslang::EbtUint16:
+                builder.addCapability(spv::CapabilityInt16);
                 spvConsts.push_back(builder.makeUint16Constant(zero ? 0 : consts[nextConst].getU16Const()));
                 break;
             case glslang::EbtInt64:
@@ -9046,6 +9286,7 @@
                 spvConsts.push_back(builder.makeDoubleConstant(zero ? 0.0 : consts[nextConst].getDConst()));
                 break;
             case glslang::EbtFloat16:
+                builder.addCapability(spv::CapabilityFloat16);
                 spvConsts.push_back(builder.makeFloat16Constant(zero ? 0.0F : (float)consts[nextConst].getDConst()));
                 break;
 #endif
@@ -9074,15 +9315,19 @@
             break;
 #ifndef GLSLANG_WEB
         case glslang::EbtInt8:
+            builder.addCapability(spv::CapabilityInt8);
             scalar = builder.makeInt8Constant(zero ? 0 : consts[nextConst].getI8Const(), specConstant);
             break;
         case glslang::EbtUint8:
+            builder.addCapability(spv::CapabilityInt8);
             scalar = builder.makeUint8Constant(zero ? 0 : consts[nextConst].getU8Const(), specConstant);
             break;
         case glslang::EbtInt16:
+            builder.addCapability(spv::CapabilityInt16);
             scalar = builder.makeInt16Constant(zero ? 0 : consts[nextConst].getI16Const(), specConstant);
             break;
         case glslang::EbtUint16:
+            builder.addCapability(spv::CapabilityInt16);
             scalar = builder.makeUint16Constant(zero ? 0 : consts[nextConst].getU16Const(), specConstant);
             break;
         case glslang::EbtInt64:
@@ -9095,6 +9340,7 @@
             scalar = builder.makeDoubleConstant(zero ? 0.0 : consts[nextConst].getDConst(), specConstant);
             break;
         case glslang::EbtFloat16:
+            builder.addCapability(spv::CapabilityFloat16);
             scalar = builder.makeFloat16Constant(zero ? 0.0F : (float)consts[nextConst].getDConst(), specConstant);
             break;
         case glslang::EbtReference:
@@ -9292,7 +9538,8 @@
     // return 7; // GLSL volatile keyword maps to both SPIR-V decorations Volatile and Coherent
     // return 8; // switch to new dead block eliminator; use OpUnreachable
     // return 9; // don't include opaque function parameters in OpEntryPoint global's operand list
-    return 10; // Generate OpFUnordNotEqual for != comparisons
+    // return 10; // Generate OpFUnordNotEqual for != comparisons
+    return 11; // Make OpEmitMeshTasksEXT a terminal instruction
 }
 
 // Write SPIR-V out to a binary file
diff --git a/SPIRV/NonSemanticShaderDebugInfo100.h b/SPIRV/NonSemanticShaderDebugInfo100.h
new file mode 100644
index 0000000..c52f32f
--- /dev/null
+++ b/SPIRV/NonSemanticShaderDebugInfo100.h
@@ -0,0 +1,171 @@
+// 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/ 
+// 
+// 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 SPIRV_UNIFIED1_NonSemanticShaderDebugInfo100_H_
+#define SPIRV_UNIFIED1_NonSemanticShaderDebugInfo100_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+    NonSemanticShaderDebugInfo100Version = 100,
+    NonSemanticShaderDebugInfo100Version_BitWidthPadding = 0x7fffffff
+};
+enum {
+    NonSemanticShaderDebugInfo100Revision = 6,
+    NonSemanticShaderDebugInfo100Revision_BitWidthPadding = 0x7fffffff
+};
+
+enum NonSemanticShaderDebugInfo100Instructions {
+    NonSemanticShaderDebugInfo100DebugInfoNone = 0,
+    NonSemanticShaderDebugInfo100DebugCompilationUnit = 1,
+    NonSemanticShaderDebugInfo100DebugTypeBasic = 2,
+    NonSemanticShaderDebugInfo100DebugTypePointer = 3,
+    NonSemanticShaderDebugInfo100DebugTypeQualifier = 4,
+    NonSemanticShaderDebugInfo100DebugTypeArray = 5,
+    NonSemanticShaderDebugInfo100DebugTypeVector = 6,
+    NonSemanticShaderDebugInfo100DebugTypedef = 7,
+    NonSemanticShaderDebugInfo100DebugTypeFunction = 8,
+    NonSemanticShaderDebugInfo100DebugTypeEnum = 9,
+    NonSemanticShaderDebugInfo100DebugTypeComposite = 10,
+    NonSemanticShaderDebugInfo100DebugTypeMember = 11,
+    NonSemanticShaderDebugInfo100DebugTypeInheritance = 12,
+    NonSemanticShaderDebugInfo100DebugTypePtrToMember = 13,
+    NonSemanticShaderDebugInfo100DebugTypeTemplate = 14,
+    NonSemanticShaderDebugInfo100DebugTypeTemplateParameter = 15,
+    NonSemanticShaderDebugInfo100DebugTypeTemplateTemplateParameter = 16,
+    NonSemanticShaderDebugInfo100DebugTypeTemplateParameterPack = 17,
+    NonSemanticShaderDebugInfo100DebugGlobalVariable = 18,
+    NonSemanticShaderDebugInfo100DebugFunctionDeclaration = 19,
+    NonSemanticShaderDebugInfo100DebugFunction = 20,
+    NonSemanticShaderDebugInfo100DebugLexicalBlock = 21,
+    NonSemanticShaderDebugInfo100DebugLexicalBlockDiscriminator = 22,
+    NonSemanticShaderDebugInfo100DebugScope = 23,
+    NonSemanticShaderDebugInfo100DebugNoScope = 24,
+    NonSemanticShaderDebugInfo100DebugInlinedAt = 25,
+    NonSemanticShaderDebugInfo100DebugLocalVariable = 26,
+    NonSemanticShaderDebugInfo100DebugInlinedVariable = 27,
+    NonSemanticShaderDebugInfo100DebugDeclare = 28,
+    NonSemanticShaderDebugInfo100DebugValue = 29,
+    NonSemanticShaderDebugInfo100DebugOperation = 30,
+    NonSemanticShaderDebugInfo100DebugExpression = 31,
+    NonSemanticShaderDebugInfo100DebugMacroDef = 32,
+    NonSemanticShaderDebugInfo100DebugMacroUndef = 33,
+    NonSemanticShaderDebugInfo100DebugImportedEntity = 34,
+    NonSemanticShaderDebugInfo100DebugSource = 35,
+    NonSemanticShaderDebugInfo100DebugFunctionDefinition = 101,
+    NonSemanticShaderDebugInfo100DebugSourceContinued = 102,
+    NonSemanticShaderDebugInfo100DebugLine = 103,
+    NonSemanticShaderDebugInfo100DebugNoLine = 104,
+    NonSemanticShaderDebugInfo100DebugBuildIdentifier = 105,
+    NonSemanticShaderDebugInfo100DebugStoragePath = 106,
+    NonSemanticShaderDebugInfo100DebugEntryPoint = 107,
+    NonSemanticShaderDebugInfo100DebugTypeMatrix = 108,
+    NonSemanticShaderDebugInfo100InstructionsMax = 0x7fffffff
+};
+
+
+enum NonSemanticShaderDebugInfo100DebugInfoFlags {
+    NonSemanticShaderDebugInfo100None = 0x0000,
+    NonSemanticShaderDebugInfo100FlagIsProtected = 0x01,
+    NonSemanticShaderDebugInfo100FlagIsPrivate = 0x02,
+    NonSemanticShaderDebugInfo100FlagIsPublic = 0x03,
+    NonSemanticShaderDebugInfo100FlagIsLocal = 0x04,
+    NonSemanticShaderDebugInfo100FlagIsDefinition = 0x08,
+    NonSemanticShaderDebugInfo100FlagFwdDecl = 0x10,
+    NonSemanticShaderDebugInfo100FlagArtificial = 0x20,
+    NonSemanticShaderDebugInfo100FlagExplicit = 0x40,
+    NonSemanticShaderDebugInfo100FlagPrototyped = 0x80,
+    NonSemanticShaderDebugInfo100FlagObjectPointer = 0x100,
+    NonSemanticShaderDebugInfo100FlagStaticMember = 0x200,
+    NonSemanticShaderDebugInfo100FlagIndirectVariable = 0x400,
+    NonSemanticShaderDebugInfo100FlagLValueReference = 0x800,
+    NonSemanticShaderDebugInfo100FlagRValueReference = 0x1000,
+    NonSemanticShaderDebugInfo100FlagIsOptimized = 0x2000,
+    NonSemanticShaderDebugInfo100FlagIsEnumClass = 0x4000,
+    NonSemanticShaderDebugInfo100FlagTypePassByValue = 0x8000,
+    NonSemanticShaderDebugInfo100FlagTypePassByReference = 0x10000,
+    NonSemanticShaderDebugInfo100FlagUnknownPhysicalLayout = 0x20000,
+    NonSemanticShaderDebugInfo100DebugInfoFlagsMax = 0x7fffffff
+};
+
+enum NonSemanticShaderDebugInfo100BuildIdentifierFlags {
+    NonSemanticShaderDebugInfo100IdentifierPossibleDuplicates = 0x01,
+    NonSemanticShaderDebugInfo100BuildIdentifierFlagsMax = 0x7fffffff
+};
+
+enum NonSemanticShaderDebugInfo100DebugBaseTypeAttributeEncoding {
+    NonSemanticShaderDebugInfo100Unspecified = 0,
+    NonSemanticShaderDebugInfo100Address = 1,
+    NonSemanticShaderDebugInfo100Boolean = 2,
+    NonSemanticShaderDebugInfo100Float = 3,
+    NonSemanticShaderDebugInfo100Signed = 4,
+    NonSemanticShaderDebugInfo100SignedChar = 5,
+    NonSemanticShaderDebugInfo100Unsigned = 6,
+    NonSemanticShaderDebugInfo100UnsignedChar = 7,
+    NonSemanticShaderDebugInfo100DebugBaseTypeAttributeEncodingMax = 0x7fffffff
+};
+
+enum NonSemanticShaderDebugInfo100DebugCompositeType {
+    NonSemanticShaderDebugInfo100Class = 0,
+    NonSemanticShaderDebugInfo100Structure = 1,
+    NonSemanticShaderDebugInfo100Union = 2,
+    NonSemanticShaderDebugInfo100DebugCompositeTypeMax = 0x7fffffff
+};
+
+enum NonSemanticShaderDebugInfo100DebugTypeQualifier {
+    NonSemanticShaderDebugInfo100ConstType = 0,
+    NonSemanticShaderDebugInfo100VolatileType = 1,
+    NonSemanticShaderDebugInfo100RestrictType = 2,
+    NonSemanticShaderDebugInfo100AtomicType = 3,
+    NonSemanticShaderDebugInfo100DebugTypeQualifierMax = 0x7fffffff
+};
+
+enum NonSemanticShaderDebugInfo100DebugOperation {
+    NonSemanticShaderDebugInfo100Deref = 0,
+    NonSemanticShaderDebugInfo100Plus = 1,
+    NonSemanticShaderDebugInfo100Minus = 2,
+    NonSemanticShaderDebugInfo100PlusUconst = 3,
+    NonSemanticShaderDebugInfo100BitPiece = 4,
+    NonSemanticShaderDebugInfo100Swap = 5,
+    NonSemanticShaderDebugInfo100Xderef = 6,
+    NonSemanticShaderDebugInfo100StackValue = 7,
+    NonSemanticShaderDebugInfo100Constu = 8,
+    NonSemanticShaderDebugInfo100Fragment = 9,
+    NonSemanticShaderDebugInfo100DebugOperationMax = 0x7fffffff
+};
+
+enum NonSemanticShaderDebugInfo100DebugImportedEntity {
+    NonSemanticShaderDebugInfo100ImportedModule = 0,
+    NonSemanticShaderDebugInfo100ImportedDeclaration = 1,
+    NonSemanticShaderDebugInfo100DebugImportedEntityMax = 0x7fffffff
+};
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // SPIRV_UNIFIED1_NonSemanticShaderDebugInfo100_H_
diff --git a/SPIRV/SPVRemapper.cpp b/SPIRV/SPVRemapper.cpp
index 56d6d5d..6aca8cb 100644
--- a/SPIRV/SPVRemapper.cpp
+++ b/SPIRV/SPVRemapper.cpp
@@ -160,15 +160,29 @@
     }
 
     // Is this an opcode we should remove when using --strip?
-    bool spirvbin_t::isStripOp(spv::Op opCode) const
+    bool spirvbin_t::isStripOp(spv::Op opCode, unsigned start) const
     {
         switch (opCode) {
         case spv::OpSource:
         case spv::OpSourceExtension:
         case spv::OpName:
         case spv::OpMemberName:
-        case spv::OpLine:           return true;
-        default:                    return false;
+        case spv::OpLine :
+        {
+            const std::string name = literalString(start + 2);
+
+            std::vector<std::string>::const_iterator it;
+            for (it = stripWhiteList.begin(); it < stripWhiteList.end(); it++)
+            {
+                if (name.find(*it) != std::string::npos) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+        default :
+            return false;
         }
     }
 
@@ -297,15 +311,21 @@
     std::string spirvbin_t::literalString(unsigned word) const
     {
         std::string literal;
+        const spirword_t * pos = spv.data() + word;
 
         literal.reserve(16);
 
-        const char* bytes = reinterpret_cast<const char*>(spv.data() + word);
-
-        while (bytes && *bytes)
-            literal += *bytes++;
-
-        return literal;
+        do {
+            spirword_t word = *pos;
+            for (int i = 0; i < 4; i++) {
+                char c = word & 0xff;
+                if (c == '\0')
+                    return literal;
+                literal += c;
+                word >>= 8;
+            }
+            pos++;
+        } while (true);
     }
 
     void spirvbin_t::applyMap()
@@ -366,7 +386,7 @@
         process(
             [&](spv::Op opCode, unsigned start) {
                 // remember opcodes we want to strip later
-                if (isStripOp(opCode))
+                if (isStripOp(opCode, start))
                     stripInst(start);
                 return true;
             },
@@ -1488,13 +1508,24 @@
     }
 
     // remap from a memory image
-    void spirvbin_t::remap(std::vector<std::uint32_t>& in_spv, std::uint32_t opts)
+    void spirvbin_t::remap(std::vector<std::uint32_t>& in_spv, const std::vector<std::string>& whiteListStrings,
+                           std::uint32_t opts)
     {
+        stripWhiteList = whiteListStrings;
         spv.swap(in_spv);
         remap(opts);
         spv.swap(in_spv);
     }
 
+    // remap from a memory image - legacy interface without white list
+    void spirvbin_t::remap(std::vector<std::uint32_t>& in_spv, std::uint32_t opts)
+    {
+      stripWhiteList.clear();
+      spv.swap(in_spv);
+      remap(opts);
+      spv.swap(in_spv);
+    }
+
 } // namespace SPV
 
 #endif // defined (use_cpp11)
diff --git a/SPIRV/SPVRemapper.h b/SPIRV/SPVRemapper.h
index d6b9c34..d216946 100644
--- a/SPIRV/SPVRemapper.h
+++ b/SPIRV/SPVRemapper.h
@@ -118,6 +118,10 @@
    virtual ~spirvbin_t() { }
 
    // remap on an existing binary in memory
+   void remap(std::vector<std::uint32_t>& spv, const std::vector<std::string>& whiteListStrings,
+              std::uint32_t opts = DO_EVERYTHING);
+
+   // remap on an existing binary in memory - legacy interface without white list
    void remap(std::vector<std::uint32_t>& spv, std::uint32_t opts = DO_EVERYTHING);
 
    // Type for error/log handler functions
@@ -180,6 +184,8 @@
    unsigned typeSizeInWords(spv::Id id)    const;
    unsigned idTypeSizeInWords(spv::Id id)  const;
 
+   bool isStripOp(spv::Op opCode, unsigned start) const;
+
    spv::Id&        asId(unsigned word)                { return spv[word]; }
    const spv::Id&  asId(unsigned word)          const { return spv[word]; }
    spv::Op         asOpCode(unsigned word)      const { return opOpCode(spv[word]); }
@@ -249,6 +255,8 @@
 
    std::vector<spirword_t> spv;      // SPIR words
 
+   std::vector<std::string> stripWhiteList;
+
    namemap_t               nameMap;  // ID names from OpName
 
    // Since we want to also do binary ops, we can't use std::vector<bool>.  we could use
diff --git a/SPIRV/SpvBuilder.cpp b/SPIRV/SpvBuilder.cpp
index e83306e..7c5ea87 100644
--- a/SPIRV/SpvBuilder.cpp
+++ b/SPIRV/SpvBuilder.cpp
@@ -59,12 +59,15 @@
 
 Builder::Builder(unsigned int spvVersion, unsigned int magicNumber, SpvBuildLogger* buildLogger) :
     spvVersion(spvVersion),
-    source(SourceLanguageUnknown),
+    sourceLang(SourceLanguageUnknown),
     sourceVersion(0),
     sourceFileStringId(NoResult),
     currentLine(0),
     currentFile(nullptr),
+    currentFileId(NoResult),
+    lastDebugScopeId(NoResult),
     emitOpLines(false),
+    emitNonSemanticShaderDebugInfo(false),
     addressModel(AddressingModelLogical),
     memoryModel(MemoryModelGLSL450),
     builderNumber(magicNumber),
@@ -98,8 +101,12 @@
 {
     if (lineNum != 0 && lineNum != currentLine) {
         currentLine = lineNum;
-        if (emitOpLines)
-            addLine(sourceFileStringId, currentLine, 0);
+        if (emitOpLines) {
+          if (emitNonSemanticShaderDebugInfo)
+              addDebugScopeAndLine(currentFileId, currentLine, 0);
+          else
+              addLine(sourceFileStringId, currentLine, 0);
+        }
     }
 }
 
@@ -118,7 +125,10 @@
         currentFile = filename;
         if (emitOpLines) {
             spv::Id strId = getStringId(filename);
-            addLine(strId, currentLine, 0);
+            if (emitNonSemanticShaderDebugInfo)
+                addDebugScopeAndLine(strId, currentLine, 0);
+            else
+                addLine(strId, currentLine, 0);
         }
     }
 }
@@ -132,22 +142,49 @@
     buildPoint->addInstruction(std::unique_ptr<Instruction>(line));
 }
 
+void Builder::addDebugScopeAndLine(Id fileName, int lineNum, int column)
+{
+    if (currentDebugScopeId.top() != lastDebugScopeId) {
+        spv::Id resultId = getUniqueId();
+        Instruction* scopeInst = new Instruction(resultId, makeVoidType(), OpExtInst);
+        scopeInst->addIdOperand(nonSemanticShaderDebugInfo);
+        scopeInst->addImmediateOperand(NonSemanticShaderDebugInfo100DebugScope);
+        scopeInst->addIdOperand(currentDebugScopeId.top());
+        buildPoint->addInstruction(std::unique_ptr<Instruction>(scopeInst));
+        lastDebugScopeId = currentDebugScopeId.top();
+    }
+    spv::Id resultId = getUniqueId();
+    Instruction* lineInst = new Instruction(resultId, makeVoidType(), OpExtInst);
+    lineInst->addIdOperand(nonSemanticShaderDebugInfo);
+    lineInst->addImmediateOperand(NonSemanticShaderDebugInfo100DebugLine);
+    lineInst->addIdOperand(makeDebugSource(fileName));
+    lineInst->addIdOperand(makeUintConstant(lineNum));
+    lineInst->addIdOperand(makeUintConstant(lineNum));
+    lineInst->addIdOperand(makeUintConstant(column));
+    lineInst->addIdOperand(makeUintConstant(column));
+    buildPoint->addInstruction(std::unique_ptr<Instruction>(lineInst));
+}
+
 // For creating new groupedTypes (will return old type if the requested one was already made).
 Id Builder::makeVoidType()
 {
     Instruction* type;
     if (groupedTypes[OpTypeVoid].size() == 0) {
-        type = new Instruction(getUniqueId(), NoType, OpTypeVoid);
+        Id typeId = getUniqueId();
+        type = new Instruction(typeId, NoType, OpTypeVoid);
         groupedTypes[OpTypeVoid].push_back(type);
         constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
         module.mapInstruction(type);
+        // Core OpTypeVoid used for debug void type
+        if (emitNonSemanticShaderDebugInfo)
+            debugId[typeId] = typeId;
     } else
         type = groupedTypes[OpTypeVoid].back();
 
     return type->getResultId();
 }
 
-Id Builder::makeBoolType()
+Id Builder::makeBoolType(bool const compilerGenerated)
 {
     Instruction* type;
     if (groupedTypes[OpTypeBool].size() == 0) {
@@ -158,6 +195,12 @@
     } else
         type = groupedTypes[OpTypeBool].back();
 
+    if (emitNonSemanticShaderDebugInfo && !compilerGenerated)
+    {
+        auto const debugResultId = makeBoolDebugType(32);
+        debugId[type->getResultId()] = debugResultId;
+    }
+
     return type->getResultId();
 }
 
@@ -172,6 +215,12 @@
     } else
         type = groupedTypes[OpTypeSampler].back();
 
+    if (emitNonSemanticShaderDebugInfo)
+    {
+        auto const debugResultId = makeCompositeDebugType({}, "type.sampler", NonSemanticShaderDebugInfo100Structure, true);
+        debugId[type->getResultId()] = debugResultId;
+    }
+
     return type->getResultId();
 }
 
@@ -268,6 +317,12 @@
         break;
     }
 
+    if (emitNonSemanticShaderDebugInfo)
+    {
+        auto const debugResultId = makeIntegerDebugType(width, hasSign);
+        debugId[type->getResultId()] = debugResultId;
+    }
+
     return type->getResultId();
 }
 
@@ -305,6 +360,12 @@
         break;
     }
 
+    if (emitNonSemanticShaderDebugInfo)
+    {
+        auto const debugResultId = makeFloatDebugType(width);
+        debugId[type->getResultId()] = debugResultId;
+    }
+
     return type->getResultId();
 }
 
@@ -312,7 +373,7 @@
 // See makeStructResultType() for non-decorated structs
 // needed as the result of some instructions, which does
 // check for duplicates.
-Id Builder::makeStructType(const std::vector<Id>& members, const char* name)
+Id Builder::makeStructType(const std::vector<Id>& members, const char* name, bool const compilerGenerated)
 {
     // Don't look for previous one, because in the general case,
     // structs can be duplicated except for decorations.
@@ -326,6 +387,12 @@
     module.mapInstruction(type);
     addName(type->getResultId(), name);
 
+    if (emitNonSemanticShaderDebugInfo && !compilerGenerated)
+    {
+        auto const debugResultId = makeCompositeDebugType(members, name, NonSemanticShaderDebugInfo100Structure);
+        debugId[type->getResultId()] = debugResultId;
+    }
+
     return type->getResultId();
 }
 
@@ -372,6 +439,12 @@
     constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
     module.mapInstruction(type);
 
+    if (emitNonSemanticShaderDebugInfo)
+    {
+        auto const debugResultId = makeVectorDebugType(component, size);
+        debugId[type->getResultId()] = debugResultId;
+    }
+
     return type->getResultId();
 }
 
@@ -398,6 +471,12 @@
     constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
     module.mapInstruction(type);
 
+    if (emitNonSemanticShaderDebugInfo)
+    {
+        auto const debugResultId = makeMatrixDebugType(column, cols);
+        debugId[type->getResultId()] = debugResultId;
+    }
+
     return type->getResultId();
 }
 
@@ -427,6 +506,37 @@
     return type->getResultId();
 }
 
+Id Builder::makeGenericType(spv::Op opcode, std::vector<spv::IdImmediate>& operands)
+{
+    // try to find it
+    Instruction* type;
+    for (int t = 0; t < (int)groupedTypes[opcode].size(); ++t) {
+        type = groupedTypes[opcode][t];
+        if (static_cast<size_t>(type->getNumOperands()) != operands.size())
+            continue; // Number mismatch, find next
+
+        bool match = true;
+        for (int op = 0; match && op < (int)operands.size(); ++op) {
+            match = (operands[op].isId ? type->getIdOperand(op) : type->getImmediateOperand(op)) == operands[op].word;
+        }
+        if (match)
+            return type->getResultId();
+    }
+
+    // not found, make it
+    type = new Instruction(getUniqueId(), NoType, opcode);
+    for (size_t op = 0; op < operands.size(); ++op) {
+        if (operands[op].isId)
+            type->addIdOperand(operands[op].word);
+        else
+            type->addImmediateOperand(operands[op].word);
+    }
+    groupedTypes[opcode].push_back(type);
+    constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+    module.mapInstruction(type);
+
+    return type->getResultId();
+}
 
 // TODO: performance: track arrays per stride
 // If a stride is supplied (non-zero) make an array.
@@ -453,6 +563,12 @@
     constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
     module.mapInstruction(type);
 
+    if (emitNonSemanticShaderDebugInfo)
+    {
+        auto const debugResultId = makeArrayDebugType(element, sizeId);
+        debugId[type->getResultId()] = debugResultId;
+    }
+
     return type->getResultId();
 }
 
@@ -463,6 +579,12 @@
     constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
     module.mapInstruction(type);
 
+    if (emitNonSemanticShaderDebugInfo)
+    {
+        auto const debugResultId = makeArrayDebugType(element, makeUintConstant(0));
+        debugId[type->getResultId()] = debugResultId;
+    }
+
     return type->getResultId();
 }
 
@@ -482,11 +604,25 @@
             }
         }
         if (! mismatch)
+        {
+            // If compiling HLSL, glslang will create a wrapper function around the entrypoint. Accordingly, a void(void)
+            // function type is created for the wrapper function. However, nonsemantic shader debug information is disabled
+            // while creating the HLSL wrapper. Consequently, if we encounter another void(void) function, we need to create
+            // the associated debug function type if it hasn't been created yet.
+            if(emitNonSemanticShaderDebugInfo && debugId[type->getResultId()] == 0) {
+                assert(sourceLang == spv::SourceLanguageHLSL);
+                assert(getTypeClass(returnType) == OpTypeVoid && paramTypes.size() == 0);
+
+                Id debugTypeId = makeDebugFunctionType(returnType, {});
+                debugId[type->getResultId()] = debugTypeId;
+            }
             return type->getResultId();
+        }
     }
 
     // not found, make it
-    type = new Instruction(getUniqueId(), NoType, OpTypeFunction);
+    Id typeId = getUniqueId();
+    type = new Instruction(typeId, NoType, OpTypeFunction);
     type->addIdOperand(returnType);
     for (int p = 0; p < (int)paramTypes.size(); ++p)
         type->addIdOperand(paramTypes[p]);
@@ -494,9 +630,34 @@
     constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
     module.mapInstruction(type);
 
+    // make debug type and map it
+    if (emitNonSemanticShaderDebugInfo) {
+        Id debugTypeId = makeDebugFunctionType(returnType, paramTypes);
+        debugId[typeId] = debugTypeId;
+    }
+
     return type->getResultId();
 }
 
+Id Builder::makeDebugFunctionType(Id returnType, const std::vector<Id>& paramTypes)
+{
+    assert(debugId[returnType] != 0);
+
+    Id typeId = getUniqueId();
+    auto type = new Instruction(typeId, makeVoidType(), OpExtInst);
+    type->addIdOperand(nonSemanticShaderDebugInfo);
+    type->addImmediateOperand(NonSemanticShaderDebugInfo100DebugTypeFunction);
+    type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100FlagIsPublic));
+    type->addIdOperand(debugId[returnType]);
+    for (auto const paramType : paramTypes) {
+        assert(isPointerType(paramType) || isArrayType(paramType));
+        type->addIdOperand(debugId[getContainedTypeId(paramType)]);
+    }
+    constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+    module.mapInstruction(type);
+    return typeId;
+}
+
 Id Builder::makeImageType(Id sampledType, Dim dim, bool depth, bool arrayed, bool ms, unsigned sampled,
     ImageFormat format)
 {
@@ -578,6 +739,22 @@
     }
 #endif
 
+    if (emitNonSemanticShaderDebugInfo)
+    {
+        auto TypeName = [&dim]() -> char const* {
+            switch (dim) {
+                case Dim1D: return "type.1d.image";
+                case Dim2D: return "type.2d.image";
+                case Dim3D: return "type.3d.image";
+                case DimCube: return "type.cube.image";
+                default: return "type.image";
+            }
+        };
+
+        auto const debugResultId = makeCompositeDebugType({}, TypeName(), NonSemanticShaderDebugInfo100Class, true);
+        debugId[type->getResultId()] = debugResultId;
+    }
+
     return type->getResultId();
 }
 
@@ -599,9 +776,376 @@
     constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
     module.mapInstruction(type);
 
+    if (emitNonSemanticShaderDebugInfo)
+    {
+        auto const debugResultId = makeCompositeDebugType({}, "type.sampled.image", NonSemanticShaderDebugInfo100Class, true);
+        debugId[type->getResultId()] = debugResultId;
+    }
+
     return type->getResultId();
 }
 
+Id Builder::makeDebugInfoNone()
+{
+    if (debugInfoNone != 0)
+        return debugInfoNone;
+
+    Instruction* inst = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
+    inst->addIdOperand(nonSemanticShaderDebugInfo);
+    inst->addImmediateOperand(NonSemanticShaderDebugInfo100DebugInfoNone);
+
+    constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(inst));
+    module.mapInstruction(inst);
+
+    debugInfoNone = inst->getResultId();
+
+    return debugInfoNone;
+}
+
+Id Builder::makeBoolDebugType(int const size)
+{
+    // 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("bool") &&
+            type->getIdOperand(1) == static_cast<unsigned int>(size) &&
+            type->getIdOperand(2) == NonSemanticShaderDebugInfo100Boolean)
+            return type->getResultId();
+    }
+
+    type = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
+    type->addIdOperand(nonSemanticShaderDebugInfo);
+    type->addImmediateOperand(NonSemanticShaderDebugInfo100DebugTypeBasic);
+
+    type->addIdOperand(getStringId("bool")); // name id
+    type->addIdOperand(makeUintConstant(size)); // size id
+    type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100Boolean)); // encoding id
+    type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100None)); // flags id
+
+    groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeBasic].push_back(type);
+    constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+    module.mapInstruction(type);
+
+    return type->getResultId();
+}
+
+Id Builder::makeIntegerDebugType(int const width, bool const hasSign)
+{
+    // 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")) &&
+            type->getIdOperand(1) == static_cast<unsigned int>(width) &&
+            type->getIdOperand(2) == (hasSign ? NonSemanticShaderDebugInfo100Signed : NonSemanticShaderDebugInfo100Unsigned))
+            return type->getResultId();
+    }
+
+    // not found, make it
+    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(makeUintConstant(width)); // size id
+    if(hasSign == true) {
+        type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100Signed)); // encoding id
+    } else {
+        type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100Unsigned)); // encoding id
+    }
+    type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100None)); // flags id
+
+    groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeBasic].push_back(type);
+    constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+    module.mapInstruction(type);
+
+    return type->getResultId();
+}
+
+Id Builder::makeFloatDebugType(int const width)
+{
+    // 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") &&
+            type->getIdOperand(1) == static_cast<unsigned int>(width) &&
+            type->getIdOperand(2) == NonSemanticShaderDebugInfo100Float)
+            return type->getResultId();
+    }
+
+    // not found, make it
+    type = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
+    type->addIdOperand(nonSemanticShaderDebugInfo);
+    type->addImmediateOperand(NonSemanticShaderDebugInfo100DebugTypeBasic);
+    type->addIdOperand(getStringId("float")); // name id
+    type->addIdOperand(makeUintConstant(width)); // size id
+    type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100Float)); // encoding id
+    type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100None)); // flags id
+
+    groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeBasic].push_back(type);
+    constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+    module.mapInstruction(type);
+
+    return type->getResultId();
+}
+
+Id Builder::makeSequentialDebugType(Id const baseType, Id const componentCount, NonSemanticShaderDebugInfo100Instructions const sequenceType)
+{
+    assert(sequenceType == NonSemanticShaderDebugInfo100DebugTypeArray ||
+        sequenceType == NonSemanticShaderDebugInfo100DebugTypeVector);
+
+    // try to find it
+    Instruction* type;
+    for (int t = 0; t < (int)groupedDebugTypes[sequenceType].size(); ++t) {
+        type = groupedDebugTypes[sequenceType][t];
+        if (type->getIdOperand(0) == baseType &&
+            type->getIdOperand(1) == makeUintConstant(componentCount))
+            return type->getResultId();
+    }
+
+    // not found, make it
+    type = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
+    type->addIdOperand(nonSemanticShaderDebugInfo);
+    type->addImmediateOperand(sequenceType);
+    type->addIdOperand(debugId[baseType]); // base type
+    type->addIdOperand(componentCount); // component count
+
+    groupedDebugTypes[sequenceType].push_back(type);
+    constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+    module.mapInstruction(type);
+
+    return type->getResultId();
+}
+
+Id Builder::makeArrayDebugType(Id const baseType, Id const componentCount)
+{
+    return makeSequentialDebugType(baseType, componentCount, NonSemanticShaderDebugInfo100DebugTypeArray);
+}
+
+Id Builder::makeVectorDebugType(Id const baseType, int const componentCount)
+{
+    return makeSequentialDebugType(baseType, makeUintConstant(componentCount), NonSemanticShaderDebugInfo100DebugTypeVector);;
+}
+
+Id Builder::makeMatrixDebugType(Id const vectorType, int const vectorCount, bool columnMajor)
+{
+    // try to find it
+    Instruction* type;
+    for (int t = 0; t < (int)groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeMatrix].size(); ++t) {
+        type = groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeMatrix][t];
+        if (type->getIdOperand(0) == vectorType &&
+            type->getIdOperand(1) == makeUintConstant(vectorCount))
+            return type->getResultId();
+    }
+
+    // not found, make it
+    type = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
+    type->addIdOperand(nonSemanticShaderDebugInfo);
+    type->addImmediateOperand(NonSemanticShaderDebugInfo100DebugTypeMatrix);
+    type->addIdOperand(debugId[vectorType]); // vector type id
+    type->addIdOperand(makeUintConstant(vectorCount)); // component count id
+    type->addIdOperand(makeBoolConstant(columnMajor)); // column-major id
+
+    groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeMatrix].push_back(type);
+    constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+    module.mapInstruction(type);
+
+    return type->getResultId();
+}
+
+Id Builder::makeMemberDebugType(Id const memberType, DebugTypeLoc const& debugTypeLoc)
+{
+    assert(debugId[memberType] != 0);
+
+    Instruction* type = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
+    type->addIdOperand(nonSemanticShaderDebugInfo);
+    type->addImmediateOperand(NonSemanticShaderDebugInfo100DebugTypeMember);
+    type->addIdOperand(getStringId(debugTypeLoc.name)); // name id
+    type->addIdOperand(debugId[memberType]); // type id
+    type->addIdOperand(makeDebugSource(sourceFileStringId)); // source id TODO: verify this works across include directives
+    type->addIdOperand(makeUintConstant(debugTypeLoc.line)); // line id TODO: currentLine is always zero
+    type->addIdOperand(makeUintConstant(debugTypeLoc.column)); // TODO: column id
+    type->addIdOperand(makeUintConstant(0)); // TODO: offset id
+    type->addIdOperand(makeUintConstant(0)); // TODO: size id
+    type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100FlagIsPublic)); // flags id
+
+    groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeMember].push_back(type);
+    constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+    module.mapInstruction(type);
+
+    return type->getResultId();
+}
+
+// Note: To represent a source language opaque type, this instruction must have no Members operands, Size operand must be
+// DebugInfoNone, and Name must start with @ to avoid clashes with user defined names.
+Id Builder::makeCompositeDebugType(std::vector<Id> const& memberTypes, char const*const name,
+    NonSemanticShaderDebugInfo100DebugCompositeType const tag, bool const isOpaqueType)
+{
+    // Create the debug member types.
+    std::vector<Id> memberDebugTypes;
+    for(auto const memberType : memberTypes) {
+        assert(debugTypeLocs.find(memberType) != debugTypeLocs.end());
+
+        memberDebugTypes.emplace_back(makeMemberDebugType(memberType, debugTypeLocs[memberType]));
+
+        // TODO: Need to rethink this method of passing location information.
+        // debugTypeLocs.erase(memberType);
+    }
+
+    // Create The structure debug type.
+    Instruction* type = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
+    type->addIdOperand(nonSemanticShaderDebugInfo);
+    type->addImmediateOperand(NonSemanticShaderDebugInfo100DebugTypeComposite);
+    type->addIdOperand(getStringId(name)); // name id
+    type->addIdOperand(makeUintConstant(tag)); // tag id
+    type->addIdOperand(makeDebugSource(sourceFileStringId)); // source id TODO: verify this works across include directives
+    type->addIdOperand(makeUintConstant(currentLine)); // line id TODO: currentLine always zero?
+    type->addIdOperand(makeUintConstant(0)); // TODO: column id
+    type->addIdOperand(makeDebugCompilationUnit()); // scope id
+    if(isOpaqueType == true) {
+        // Prepend '@' to opaque types.
+        type->addIdOperand(getStringId('@' + std::string(name))); // linkage name id
+        type->addIdOperand(makeDebugInfoNone()); // size id
+    } else {
+        type->addIdOperand(getStringId(name)); // linkage name id
+        type->addIdOperand(makeUintConstant(0)); // TODO: size id
+    }
+    type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100FlagIsPublic)); // flags id
+    assert(isOpaqueType == false || (isOpaqueType == true && memberDebugTypes.empty()));
+    for(auto const memberDebugType : memberDebugTypes) {
+        type->addIdOperand(memberDebugType);
+    }
+
+    groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeComposite].push_back(type);
+    constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+    module.mapInstruction(type);
+
+    return type->getResultId();
+}
+
+Id Builder::makeDebugSource(const Id fileName) {
+    if (debugSourceId.find(fileName) != debugSourceId.end())
+        return debugSourceId[fileName];
+    spv::Id resultId = getUniqueId();
+    Instruction* sourceInst = new Instruction(resultId, makeVoidType(), OpExtInst);
+    sourceInst->addIdOperand(nonSemanticShaderDebugInfo);
+    sourceInst->addImmediateOperand(NonSemanticShaderDebugInfo100DebugSource);
+    sourceInst->addIdOperand(fileName);
+    if (emitNonSemanticShaderDebugSource) {
+        spv::Id sourceId = 0;
+        if (fileName == sourceFileStringId) {
+            sourceId = getStringId(sourceText);
+        } else {
+            auto incItr = includeFiles.find(fileName);
+            assert(incItr != includeFiles.end());
+            sourceId = getStringId(*incItr->second);
+        }
+        sourceInst->addIdOperand(sourceId);
+    }
+    constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(sourceInst));
+    module.mapInstruction(sourceInst);
+    debugSourceId[fileName] = resultId;
+    return resultId;
+}
+
+Id Builder::makeDebugCompilationUnit() {
+    if (nonSemanticShaderCompilationUnitId != 0)
+        return nonSemanticShaderCompilationUnitId;
+    spv::Id resultId = getUniqueId();
+    Instruction* sourceInst = new Instruction(resultId, makeVoidType(), OpExtInst);
+    sourceInst->addIdOperand(nonSemanticShaderDebugInfo);
+    sourceInst->addImmediateOperand(NonSemanticShaderDebugInfo100DebugCompilationUnit);
+    sourceInst->addIdOperand(makeUintConstant(1)); // TODO(greg-lunarg): Get rid of magic number
+    sourceInst->addIdOperand(makeUintConstant(4)); // TODO(greg-lunarg): Get rid of magic number
+    sourceInst->addIdOperand(makeDebugSource(sourceFileStringId));
+    sourceInst->addIdOperand(makeUintConstant(sourceLang));
+    constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(sourceInst));
+    module.mapInstruction(sourceInst);
+    nonSemanticShaderCompilationUnitId = resultId;
+    return resultId;
+}
+
+Id Builder::createDebugGlobalVariable(Id const type, char const*const name, Id const variable)
+{
+    assert(type != 0);
+
+    Instruction* inst = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
+    inst->addIdOperand(nonSemanticShaderDebugInfo);
+    inst->addImmediateOperand(NonSemanticShaderDebugInfo100DebugGlobalVariable);
+    inst->addIdOperand(getStringId(name)); // name id
+    inst->addIdOperand(type); // type id
+    inst->addIdOperand(makeDebugSource(sourceFileStringId)); // source id
+    inst->addIdOperand(makeUintConstant(currentLine)); // line id TODO: currentLine always zero?
+    inst->addIdOperand(makeUintConstant(0)); // TODO: column id
+    inst->addIdOperand(makeDebugCompilationUnit()); // scope id
+    inst->addIdOperand(getStringId(name)); // linkage name id
+    inst->addIdOperand(variable); // variable id
+    inst->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100FlagIsDefinition)); // flags id
+
+    constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(inst));
+    module.mapInstruction(inst);
+
+    return inst->getResultId();
+}
+
+Id Builder::createDebugLocalVariable(Id type, char const*const name, size_t const argNumber)
+{
+    assert(name != nullptr);
+    Instruction* inst = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
+    inst->addIdOperand(nonSemanticShaderDebugInfo);
+    inst->addImmediateOperand(NonSemanticShaderDebugInfo100DebugLocalVariable);
+    inst->addIdOperand(getStringId(name)); // name id
+    inst->addIdOperand(type); // type id
+    inst->addIdOperand(makeDebugSource(sourceFileStringId)); // source id
+    inst->addIdOperand(makeUintConstant(currentLine)); // line id
+    inst->addIdOperand(makeUintConstant(0)); // TODO: column id
+    inst->addIdOperand(currentDebugScopeId.top()); // scope id
+    inst->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100FlagIsLocal)); // flags id
+    if(argNumber != 0) {
+        inst->addIdOperand(makeUintConstant(argNumber));
+    }
+
+    constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(inst));
+    module.mapInstruction(inst);
+
+    return inst->getResultId();
+}
+
+Id Builder::makeDebugExpression()
+{
+    if (debugExpression != 0)
+        return debugExpression;
+
+    Instruction* inst = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
+    inst->addIdOperand(nonSemanticShaderDebugInfo);
+    inst->addImmediateOperand(NonSemanticShaderDebugInfo100DebugExpression);
+
+    constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(inst));
+    module.mapInstruction(inst);
+
+    debugExpression = inst->getResultId();
+
+    return debugExpression;
+}
+
+Id Builder::makeDebugDeclare(Id const debugLocalVariable, Id const localVariable)
+{
+    Instruction* inst = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
+    inst->addIdOperand(nonSemanticShaderDebugInfo);
+    inst->addImmediateOperand(NonSemanticShaderDebugInfo100DebugDeclare);
+    inst->addIdOperand(debugLocalVariable); // debug local variable id
+    inst->addIdOperand(localVariable); // local variable id
+    inst->addIdOperand(makeDebugExpression()); // expression id
+    buildPoint->addInstruction(std::unique_ptr<Instruction>(inst));
+
+    return inst->getResultId();
+}
+
 #ifndef GLSLANG_WEB
 Id Builder::makeAccelerationStructureType()
 {
@@ -889,6 +1433,17 @@
     }
 }
 
+bool Builder::isRayTracingOpCode(Op opcode) const
+{
+    switch (opcode) {
+    case OpTypeAccelerationStructureKHR:
+    case OpTypeRayQueryKHR:
+        return true;
+    default:
+        return false;
+    }
+}
+
 Id Builder::makeNullConstant(Id typeId)
 {
     Instruction* constant;
@@ -1105,6 +1660,19 @@
     return NoResult;
 }
 
+Id Builder::importNonSemanticShaderDebugInfoInstructions()
+{
+    assert(emitNonSemanticShaderDebugInfo == true);
+
+    if(nonSemanticShaderDebugInfo == 0)
+    {
+        this->addExtension(spv::E_SPV_KHR_non_semantic_info);
+        nonSemanticShaderDebugInfo = this->import("NonSemantic.Shader.DebugInfo.100");
+    }
+
+    return nonSemanticShaderDebugInfo;
+}
+
 Id Builder::findCompositeConstant(Op typeClass, Id typeId, const std::vector<Id>& comps)
 {
     Instruction* constant = 0;
@@ -1416,23 +1984,34 @@
     assert(! entryPointFunction);
 
     Block* entry;
-    std::vector<Id> params;
+    std::vector<Id> paramsTypes;
+    std::vector<char const*> paramNames;
     std::vector<std::vector<Decoration>> decorations;
 
-    entryPointFunction = makeFunctionEntry(NoPrecision, makeVoidType(), entryPoint, params, decorations, &entry);
+    auto const returnType = makeVoidType();
+
+    restoreNonSemanticShaderDebugInfo = emitNonSemanticShaderDebugInfo;
+    if(sourceLang == spv::SourceLanguageHLSL) {
+        emitNonSemanticShaderDebugInfo = false;
+    }
+
+    entryPointFunction = makeFunctionEntry(NoPrecision, returnType, entryPoint, paramsTypes, paramNames, decorations, &entry);
+
+    emitNonSemanticShaderDebugInfo = restoreNonSemanticShaderDebugInfo;
 
     return entryPointFunction;
 }
 
 // Comments in header
 Function* Builder::makeFunctionEntry(Decoration precision, Id returnType, const char* name,
-                                     const std::vector<Id>& paramTypes,
+                                     const std::vector<Id>& paramTypes, const std::vector<char const*>& paramNames,
                                      const std::vector<std::vector<Decoration>>& decorations, Block **entry)
 {
     // Make the function and initial instructions in it
     Id typeId = makeFunctionType(returnType, paramTypes);
     Id firstParamId = paramTypes.size() == 0 ? 0 : getUniqueIds((int)paramTypes.size());
-    Function* function = new Function(getUniqueId(), returnType, typeId, firstParamId, module);
+    Id funcId = getUniqueId();
+    Function* function = new Function(funcId, returnType, typeId, firstParamId, module);
 
     // Set up the precisions
     setPrecision(function->getId(), precision);
@@ -1444,11 +2023,39 @@
         }
     }
 
+    // Make the debug function instruction
+    if (emitNonSemanticShaderDebugInfo) {
+        Id nameId = getStringId(unmangleFunctionName(name));
+        Id debugFuncId = makeDebugFunction(function, nameId, typeId);
+        debugId[funcId] = debugFuncId;
+        currentDebugScopeId.push(debugFuncId);
+        lastDebugScopeId = NoResult;
+    }
+
     // CFG
-    if (entry) {
-        *entry = new Block(getUniqueId(), *function);
-        function->addBlock(*entry);
-        setBuildPoint(*entry);
+    assert(entry != nullptr);
+    *entry = new Block(getUniqueId(), *function);
+    function->addBlock(*entry);
+    setBuildPoint(*entry);
+
+    // DebugScope and DebugLine for parameter DebugDeclares
+    if (emitNonSemanticShaderDebugInfo && (int)paramTypes.size() > 0) {
+        addDebugScopeAndLine(currentFileId, currentLine, 0);
+    }
+
+    if (emitNonSemanticShaderDebugInfo) {
+        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 const& paramName = paramNames[p];
+            auto const debugLocalVariableId = createDebugLocalVariable(debugId[getContainedTypeId(paramType)], paramName, p+1);
+            debugId[firstParamId + p] = debugLocalVariableId;
+
+            makeDebugDeclare(debugLocalVariableId, firstParamId + p);
+        }
     }
 
     if (name)
@@ -1456,9 +2063,62 @@
 
     functions.push_back(std::unique_ptr<Function>(function));
 
+    // Clear debug scope stack
+    if (emitNonSemanticShaderDebugInfo)
+        currentDebugScopeId.pop();
+
     return function;
 }
 
+Id Builder::makeDebugFunction(Function* function, Id nameId, Id funcTypeId) {
+    assert(function != nullptr);
+    assert(nameId != 0);
+    assert(funcTypeId != 0);
+    assert(debugId[funcTypeId] != 0);
+
+    Id funcId = getUniqueId();
+    auto type = new Instruction(funcId, makeVoidType(), OpExtInst);
+    type->addIdOperand(nonSemanticShaderDebugInfo);
+    type->addImmediateOperand(NonSemanticShaderDebugInfo100DebugFunction);
+    type->addIdOperand(nameId);
+    type->addIdOperand(debugId[funcTypeId]);
+    type->addIdOperand(makeDebugSource(currentFileId)); // Will be fixed later when true filename available
+    type->addIdOperand(makeUintConstant(currentLine)); // Will be fixed later when true line available
+    type->addIdOperand(makeUintConstant(0)); // column
+    type->addIdOperand(makeDebugCompilationUnit()); // scope
+    type->addIdOperand(nameId); // linkage name
+    type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100FlagIsPublic));
+    type->addIdOperand(makeUintConstant(currentLine)); // TODO(greg-lunarg): correct scope line
+    constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+    module.mapInstruction(type);
+    return funcId;
+}
+
+Id Builder::makeDebugLexicalBlock(uint32_t line) {
+    Id lexId = getUniqueId();
+    auto lex = new Instruction(lexId, makeVoidType(), OpExtInst);
+    lex->addIdOperand(nonSemanticShaderDebugInfo);
+    lex->addImmediateOperand(NonSemanticShaderDebugInfo100DebugLexicalBlock);
+    lex->addIdOperand(makeDebugSource(currentFileId));
+    lex->addIdOperand(makeUintConstant(line));
+    lex->addIdOperand(makeUintConstant(0)); // column
+    lex->addIdOperand(currentDebugScopeId.top()); // scope
+    constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(lex));
+    module.mapInstruction(lex);
+    return lexId;
+}
+
+std::string Builder::unmangleFunctionName(std::string const& name) const
+{
+    assert(name.length() > 0);
+
+    if(name.rfind('(') != std::string::npos) {
+        return name.substr(0, name.rfind('('));
+    } else {
+        return name;
+    }
+}
+
 // Comments in header
 void Builder::makeReturn(bool implicit, Id retVal)
 {
@@ -1474,6 +2134,48 @@
 }
 
 // Comments in header
+void Builder::enterScope(uint32_t line)
+{
+    // Generate new lexical scope debug instruction
+    Id lexId = makeDebugLexicalBlock(line);
+    currentDebugScopeId.push(lexId);
+    lastDebugScopeId = NoResult;
+}
+
+// Comments in header
+void Builder::leaveScope()
+{
+    // Pop current scope from stack and clear current scope
+    currentDebugScopeId.pop();
+    lastDebugScopeId = NoResult;
+}
+
+// Comments in header
+void Builder::enterFunction(Function const* function)
+{
+    // Save and disable debugInfo for HLSL entry point function. It is a wrapper
+    // function with no user code in it.
+    restoreNonSemanticShaderDebugInfo = emitNonSemanticShaderDebugInfo;
+    if (sourceLang == spv::SourceLanguageHLSL && function == entryPointFunction) {
+        emitNonSemanticShaderDebugInfo = false;
+    }
+
+    if (emitNonSemanticShaderDebugInfo) {
+        // Initialize scope state
+        Id funcId = function->getFuncId();
+        currentDebugScopeId.push(debugId[funcId]);
+        // Create DebugFunctionDefinition
+        spv::Id resultId = getUniqueId();
+        Instruction* defInst = new Instruction(resultId, makeVoidType(), OpExtInst);
+        defInst->addIdOperand(nonSemanticShaderDebugInfo);
+        defInst->addImmediateOperand(NonSemanticShaderDebugInfo100DebugFunctionDefinition);
+        defInst->addIdOperand(debugId[funcId]);
+        defInst->addIdOperand(funcId);
+        buildPoint->addInstruction(std::unique_ptr<Instruction>(defInst));
+    }
+}
+
+// Comments in header
 void Builder::leaveFunction()
 {
     Block* block = buildPoint;
@@ -1488,6 +2190,12 @@
             makeReturn(true, createUndefined(function.getReturnType()));
         }
     }
+
+    // Clear function scope from debug scope stack
+    if (emitNonSemanticShaderDebugInfo)
+        currentDebugScopeId.pop();
+
+    emitNonSemanticShaderDebugInfo = restoreNonSemanticShaderDebugInfo;
 }
 
 // Comments in header
@@ -1498,7 +2206,18 @@
 }
 
 // Comments in header
-Id Builder::createVariable(Decoration precision, StorageClass storageClass, Id type, const char* name, Id initializer)
+void Builder::makeStatementTerminator(spv::Op opcode, const std::vector<Id>& operands, const char* name)
+{
+    // It's assumed that the terminator instruction is always of void return type
+    // However in future if there is a need for non void return type, new helper
+    // methods can be created.
+    createNoResultOp(opcode, operands);
+    createAndSetNoPredecessorBlock(name);
+}
+
+// Comments in header
+Id Builder::createVariable(Decoration precision, StorageClass storageClass, Id type, const char* name, Id initializer,
+    bool const compilerGenerated)
 {
     Id pointerType = makePointer(storageClass, type);
     Instruction* inst = new Instruction(getUniqueId(), pointerType, OpVariable);
@@ -1510,11 +2229,26 @@
     case StorageClassFunction:
         // Validation rules require the declaration in the entry block
         buildPoint->getParent().addLocalVariable(std::unique_ptr<Instruction>(inst));
+
+        if (emitNonSemanticShaderDebugInfo && !compilerGenerated)
+        {
+            auto const debugLocalVariableId = createDebugLocalVariable(debugId[type], name);
+            debugId[inst->getResultId()] = debugLocalVariableId;
+
+            makeDebugDeclare(debugLocalVariableId, inst->getResultId());
+        }
+
         break;
 
     default:
         constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(inst));
         module.mapInstruction(inst);
+
+        if (emitNonSemanticShaderDebugInfo && !isRayTracingOpCode(getOpCode(type)))
+        {
+            auto const debugResultId = createDebugGlobalVariable(debugId[type], name, inst->getResultId());
+            debugId[inst->getResultId()] = debugResultId;
+        }
         break;
     }
 
@@ -1544,7 +2278,7 @@
     case spv::StorageClassPhysicalStorageBufferEXT:
         break;
     default:
-        memoryAccess = spv::MemoryAccessMask(memoryAccess & 
+        memoryAccess = spv::MemoryAccessMask(memoryAccess &
                         ~(spv::MemoryAccessMakePointerAvailableKHRMask |
                           spv::MemoryAccessMakePointerVisibleKHRMask |
                           spv::MemoryAccessNonPrivatePointerKHRMask));
@@ -2020,7 +2754,7 @@
         texArgs[numArgs++] = parameters.granularity;
     if (parameters.coarse != NoResult)
         texArgs[numArgs++] = parameters.coarse;
-#endif 
+#endif
 
     //
     // Set up the optional arguments
@@ -3240,10 +3974,10 @@
     const int opSourceWordCount = 4;
     const int nonNullBytesPerInstruction = 4 * (maxWordCount - opSourceWordCount) - 1;
 
-    if (source != SourceLanguageUnknown) {
+    if (sourceLang != SourceLanguageUnknown) {
         // OpSource Language Version File Source
         Instruction sourceInst(NoResult, NoType, OpSource);
-        sourceInst.addImmediateOperand(source);
+        sourceInst.addImmediateOperand(sourceLang);
         sourceInst.addImmediateOperand(sourceVersion);
         // File operand
         if (fileId != NoResult) {
@@ -3276,6 +4010,7 @@
 // Dump an OpSource[Continued] sequence for the source and every include file
 void Builder::dumpSourceInstructions(std::vector<unsigned int>& out) const
 {
+    if (emitNonSemanticShaderDebugInfo) return;
     dumpSourceInstructions(sourceFileStringId, sourceText, out);
     for (auto iItr = includeFiles.begin(); iItr != includeFiles.end(); ++iItr)
         dumpSourceInstructions(iItr->first, *iItr->second, out);
diff --git a/SPIRV/SpvBuilder.h b/SPIRV/SpvBuilder.h
index 251b9ee..f7fdc6a 100644
--- a/SPIRV/SpvBuilder.h
+++ b/SPIRV/SpvBuilder.h
@@ -50,6 +50,10 @@
 #include "Logger.h"
 #include "spirv.hpp"
 #include "spvIR.h"
+namespace spv {
+    #include "GLSL.ext.KHR.h"
+    #include "NonSemanticShaderDebugInfo100.h"
+}
 
 #include <algorithm>
 #include <map>
@@ -82,7 +86,7 @@
 
     void setSource(spv::SourceLanguage lang, int version)
     {
-        source = lang;
+        sourceLang = lang;
         sourceVersion = version;
     }
     spv::Id getStringId(const std::string& str)
@@ -99,14 +103,32 @@
         stringIds[file_c_str] = strId;
         return strId;
     }
+    spv::Id getSourceFile() const 
+    {
+        return sourceFileStringId;
+    }
     void setSourceFile(const std::string& file)
     {
         sourceFileStringId = getStringId(file);
+        currentFileId = sourceFileStringId;
     }
     void setSourceText(const std::string& text) { sourceText = text; }
     void addSourceExtension(const char* ext) { sourceExtensions.push_back(ext); }
     void addModuleProcessed(const std::string& p) { moduleProcesses.push_back(p.c_str()); }
     void setEmitOpLines() { emitOpLines = true; }
+    void setEmitNonSemanticShaderDebugInfo(bool const emit)
+    {
+        emitNonSemanticShaderDebugInfo = emit;
+
+        if(emit)
+        {
+            importNonSemanticShaderDebugInfoInstructions();
+        }
+    }
+    void setEmitNonSemanticShaderDebugSource(bool const src)
+    {
+        emitNonSemanticShaderDebugSource = src;
+    }
     void addExtension(const char* ext) { extensions.insert(ext); }
     void removeExtension(const char* ext)
     {
@@ -159,10 +181,11 @@
     void setLine(int line, const char* filename);
     // Low-level OpLine. See setLine() for a layered helper.
     void addLine(Id fileName, int line, int column);
+    void addDebugScopeAndLine(Id fileName, int line, int column);
 
     // For creating new types (will return old type if the requested one was already made).
     Id makeVoidType();
-    Id makeBoolType();
+    Id makeBoolType(bool const compilerGenerated = true);
     Id makePointer(StorageClass, Id pointee);
     Id makeForwardPointer(StorageClass);
     Id makePointerFromForwardPointer(StorageClass, Id forwardPointerType, Id pointee);
@@ -170,7 +193,7 @@
     Id makeIntType(int width) { return makeIntegerType(width, true); }
     Id makeUintType(int width) { return makeIntegerType(width, false); }
     Id makeFloatType(int width);
-    Id makeStructType(const std::vector<Id>& members, const char*);
+    Id makeStructType(const std::vector<Id>& members, const char* name, bool const compilerGenerated = true);
     Id makeStructResultType(Id type0, Id type1);
     Id makeVectorType(Id component, int size);
     Id makeMatrixType(Id component, int cols, int rows);
@@ -181,6 +204,37 @@
     Id makeSamplerType();
     Id makeSampledImageType(Id imageType);
     Id makeCooperativeMatrixType(Id component, Id scope, Id rows, Id cols);
+    Id makeGenericType(spv::Op opcode, std::vector<spv::IdImmediate>& operands);
+
+    // SPIR-V NonSemantic Shader DebugInfo Instructions
+    struct DebugTypeLoc {
+        std::string name {};
+        int line {0};
+        int column {0};
+    };
+    std::unordered_map<Id, DebugTypeLoc> debugTypeLocs;
+    Id makeDebugInfoNone();
+    Id makeBoolDebugType(int const size);
+    Id makeIntegerDebugType(int const width, bool const hasSign);
+    Id makeFloatDebugType(int const width);
+    Id makeSequentialDebugType(Id const baseType, Id const componentCount, NonSemanticShaderDebugInfo100Instructions const sequenceType);
+    Id makeArrayDebugType(Id const baseType, Id const componentCount);
+    Id makeVectorDebugType(Id const baseType, int const componentCount);
+    Id makeMatrixDebugType(Id const vectorType, int const vectorCount, bool columnMajor = true);
+    Id makeMemberDebugType(Id const memberType, DebugTypeLoc const& debugTypeLoc);
+    Id makeCompositeDebugType(std::vector<Id> const& memberTypes, char const*const name,
+        NonSemanticShaderDebugInfo100DebugCompositeType const tag, bool const isOpaqueType = false);
+    Id makeDebugSource(const Id fileName);
+    Id makeDebugCompilationUnit();
+    Id createDebugGlobalVariable(Id const type, char const*const name, Id const variable);
+    Id createDebugLocalVariable(Id type, char const*const name, size_t const argNumber = 0);
+    Id makeDebugExpression();
+    Id makeDebugDeclare(Id const debugLocalVariable, Id const localVariable);
+    Id makeDebugValue(Id const debugLocalVariable, Id const value);
+    Id makeDebugFunctionType(Id returnType, const std::vector<Id>& paramTypes);
+    Id makeDebugFunction(Function* function, Id nameId, Id funcTypeId);
+    Id makeDebugLexicalBlock(uint32_t line);
+    std::string unmangleFunctionName(std::string const& name) const;
 
     // accelerationStructureNV type
     Id makeAccelerationStructureType();
@@ -256,6 +310,8 @@
     // See if a resultId is valid for use as an initializer.
     bool isValidInitializer(Id resultId) const { return isConstant(resultId) || isGlobalVariable(resultId); }
 
+    bool isRayTracingOpCode(Op opcode) const;
+
     int getScalarTypeWidth(Id typeId) const
     {
         Id scalarTypeId = getScalarTypeId(typeId);
@@ -317,6 +373,8 @@
     Id makeFloat16Constant(float f16, bool specConstant = false);
     Id makeFpConstant(Id type, double d, bool specConstant = false);
 
+    Id importNonSemanticShaderDebugInfoInstructions();
+
     // Turn the array of constants into a proper spv constant of the requested type.
     Id makeCompositeConstant(Id type, const std::vector<Id>& comps, bool specConst = false);
 
@@ -339,7 +397,12 @@
     void addMemberDecoration(Id, unsigned int member, Decoration, const std::vector<const char*>& strings);
 
     // At the end of what block do the next create*() instructions go?
-    void setBuildPoint(Block* bp) { buildPoint = bp; }
+    // Also reset current last DebugScope and current source line to unknown
+    void setBuildPoint(Block* bp) {
+        buildPoint = bp;
+        lastDebugScopeId = NoResult;
+        currentLine = 0;
+    }
     Block* getBuildPoint() const { return buildPoint; }
 
     // Make the entry-point function. The returned pointer is only valid
@@ -350,12 +413,22 @@
     // 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<std::vector<Decoration>>& precisions, Block **entry = 0);
+        const std::vector<Id>& paramTypes, const std::vector<char const*>& paramNames,
+        const std::vector<std::vector<Decoration>>& precisions, Block **entry = 0);
 
     // 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.
     void makeReturn(bool implicit, Id retVal = 0);
 
+    // Initialize state and generate instructions for new lexical scope
+    void enterScope(uint32_t line);
+
+    // Set state and generate instructions to exit current lexical scope
+    void leaveScope();
+
+    // Prepare builder for generation of instructions for a function.
+    void enterFunction(Function const* function);
+
     // Generate all the code needed to finish up a function.
     void leaveFunction();
 
@@ -363,9 +436,13 @@
     // discard, terminate-invocation, terminateRayEXT, or ignoreIntersectionEXT
     void makeStatementTerminator(spv::Op opcode, const char *name);
 
+    // Create block terminator instruction for statements that have input operands
+    // such as OpEmitMeshTasksEXT
+    void makeStatementTerminator(spv::Op opcode, const std::vector<Id>& operands, const char* name);
+
     // Create a global or function local or IO variable.
-    Id createVariable(Decoration precision, StorageClass, Id type, const char* name = nullptr,
-        Id initializer = NoResult);
+    Id createVariable(Decoration precision, StorageClass storageClass, Id type, const char* name = nullptr,
+        Id initializer = NoResult, bool const compilerGenerated = true);
 
     // Create an intermediate with an undefined value.
     Id createUndefined(Id type);
@@ -800,13 +877,23 @@
         const;
 
     unsigned int spvVersion;     // the version of SPIR-V to emit in the header
-    SourceLanguage source;
+    SourceLanguage sourceLang;
     int sourceVersion;
     spv::Id sourceFileStringId;
+    spv::Id nonSemanticShaderCompilationUnitId {0};
+    spv::Id nonSemanticShaderDebugInfo {0};
+    spv::Id debugInfoNone {0};
+    spv::Id debugExpression {0}; // Debug expression with zero operations.
     std::string sourceText;
     int currentLine;
     const char* currentFile;
+    spv::Id currentFileId;
+    std::stack<spv::Id> currentDebugScopeId;
+    spv::Id lastDebugScopeId;
     bool emitOpLines;
+    bool emitNonSemanticShaderDebugInfo;
+    bool restoreNonSemanticShaderDebugInfo;
+    bool emitNonSemanticShaderDebugSource;
     std::set<std::string> extensions;
     std::vector<const char*> sourceExtensions;
     std::vector<const char*> moduleProcesses;
@@ -840,6 +927,8 @@
     std::unordered_map<unsigned int, std::vector<Instruction*>> groupedStructConstants;
     // map type opcodes to type instructions
     std::unordered_map<unsigned int, std::vector<Instruction*>> groupedTypes;
+    // map type opcodes to debug type instructions
+    std::unordered_map<unsigned int, std::vector<Instruction*>> groupedDebugTypes;
     // list of OpConstantNull instructions
     std::vector<Instruction*> nullConstants;
 
@@ -855,6 +944,12 @@
     // map from include file name ids to their contents
     std::map<spv::Id, const std::string*> includeFiles;
 
+    // map from core id to debug id
+    std::map <spv::Id, spv::Id> debugId;
+
+    // map from file name string id to DebugSource id
+    std::unordered_map<spv::Id, spv::Id> debugSourceId;
+
     // The stream for outputting warnings and errors.
     SpvBuildLogger* logger;
 };  // end Builder class
diff --git a/SPIRV/SpvTools.cpp b/SPIRV/SpvTools.cpp
index 8acf9b1..2529993 100644
--- a/SPIRV/SpvTools.cpp
+++ b/SPIRV/SpvTools.cpp
@@ -68,6 +68,8 @@
         }
     case glslang::EShTargetVulkan_1_2:
         return spv_target_env::SPV_ENV_VULKAN_1_2;
+    case glslang::EShTargetVulkan_1_3:
+        return spv_target_env::SPV_ENV_VULKAN_1_3;
     default:
         break;
     }
@@ -210,6 +212,8 @@
     optimizer.RegisterPass(spvtools::CreateInterpolateFixupPass());
     if (options->optimizeSize) {
         optimizer.RegisterPass(spvtools::CreateRedundancyEliminationPass());
+        if (intermediate.getStage() == EShLanguage::EShLangVertex)
+            optimizer.RegisterPass(spvtools::CreateEliminateDeadInputComponentsPass());
     }
     optimizer.RegisterPass(spvtools::CreateAggressiveDCEPass());
     optimizer.RegisterPass(spvtools::CreateCFGCleanupPass());
diff --git a/SPIRV/SpvTools.h b/SPIRV/SpvTools.h
index 3fb3cba..5386048 100644
--- a/SPIRV/SpvTools.h
+++ b/SPIRV/SpvTools.h
@@ -53,14 +53,14 @@
 namespace glslang {
 
 struct SpvOptions {
-    SpvOptions() : generateDebugInfo(false), stripDebugInfo(false), disableOptimizer(true),
-        optimizeSize(false), disassemble(false), validate(false) { }
-    bool generateDebugInfo;
-    bool stripDebugInfo;
-    bool disableOptimizer;
-    bool optimizeSize;
-    bool disassemble;
-    bool validate;
+    bool generateDebugInfo {false};
+    bool stripDebugInfo {false};
+    bool disableOptimizer {true};
+    bool optimizeSize {false};
+    bool disassemble {false};
+    bool validate {false};
+    bool emitNonSemanticShaderDebugInfo {false};
+    bool emitNonSemanticShaderDebugSource{ false };
 };
 
 #if ENABLE_OPT
diff --git a/SPIRV/disassemble.cpp b/SPIRV/disassemble.cpp
index 73c988c..74dd605 100644
--- a/SPIRV/disassemble.cpp
+++ b/SPIRV/disassemble.cpp
@@ -43,6 +43,7 @@
 #include <stack>
 #include <sstream>
 #include <cstring>
+#include <utility>
 
 #include "disassemble.h"
 #include "doc.h"
@@ -100,6 +101,7 @@
     void outputMask(OperandClass operandClass, unsigned mask);
     void disassembleImmediates(int numOperands);
     void disassembleIds(int numOperands);
+    std::pair<int, std::string> decodeString();
     int disassembleString();
     void disassembleInstruction(Id resultId, Id typeId, Op opCode, int numOperands);
 
@@ -290,31 +292,44 @@
     }
 }
 
-// return the number of operands consumed by the string
-int SpirvStream::disassembleString()
+// decode string from words at current position (non-consuming)
+std::pair<int, std::string> SpirvStream::decodeString()
 {
-    int startWord = word;
-
-    out << " \"";
-
-    const char* wordString;
+    std::string res;
+    int wordPos = word;
+    char c;
     bool done = false;
+
     do {
-        unsigned int content = stream[word];
-        wordString = (const char*)&content;
+        unsigned int content = stream[wordPos];
         for (int charCount = 0; charCount < 4; ++charCount) {
-            if (*wordString == 0) {
+            c = content & 0xff;
+            content >>= 8;
+            if (c == '\0') {
                 done = true;
                 break;
             }
-            out << *(wordString++);
+            res += c;
         }
-        ++word;
-    } while (! done);
+        ++wordPos;
+    } while(! done);
 
+    return std::make_pair(wordPos - word, res);
+}
+
+// return the number of operands consumed by the string
+int SpirvStream::disassembleString()
+{
+    out << " \"";
+
+    std::pair<int, std::string> decoderes = decodeString();
+
+    out << decoderes.second;
     out << "\"";
 
-    return word - startWord;
+    word += decoderes.first;
+
+    return decoderes.first;
 }
 
 void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode, int numOperands)
@@ -331,7 +346,7 @@
             nextNestedControl = 0;
         }
     } else if (opCode == OpExtInstImport) {
-        idDescriptor[resultId] = (const char*)(&stream[word]);
+        idDescriptor[resultId] = decodeString().second;
     }
     else {
         if (resultId != 0 && idDescriptor[resultId].size() == 0) {
@@ -428,7 +443,7 @@
             --numOperands;
             // Get names for printing "(XXX)" for readability, *after* this id
             if (opCode == OpName)
-                idDescriptor[stream[word - 1]] = (const char*)(&stream[word]);
+                idDescriptor[stream[word - 1]] = decodeString().second;
             break;
         case OperandVariableIds:
             disassembleIds(numOperands);
diff --git a/SPIRV/doc.cpp b/SPIRV/doc.cpp
index dbdf707..b7fe3e7 100644
--- a/SPIRV/doc.cpp
+++ b/SPIRV/doc.cpp
@@ -97,6 +97,8 @@
     case 6:  return "Kernel";
     case ExecutionModelTaskNV: return "TaskNV";
     case ExecutionModelMeshNV: return "MeshNV";
+    case ExecutionModelTaskEXT: return "TaskEXT";
+    case ExecutionModelMeshEXT: return "MeshEXT";
 
     default: return "Bad";
 
@@ -173,28 +175,32 @@
     case 31: return "ContractionOff";
     case 32: return "Bad";
 
-    case ExecutionModeInitializer:              return "Initializer";
-    case ExecutionModeFinalizer:                return "Finalizer";
-    case ExecutionModeSubgroupSize:             return "SubgroupSize";
-    case ExecutionModeSubgroupsPerWorkgroup:    return "SubgroupsPerWorkgroup";
-    case ExecutionModeSubgroupsPerWorkgroupId:  return "SubgroupsPerWorkgroupId";
-    case ExecutionModeLocalSizeId:              return "LocalSizeId";
-    case ExecutionModeLocalSizeHintId:          return "LocalSizeHintId";
+    case ExecutionModeInitializer:                   return "Initializer";
+    case ExecutionModeFinalizer:                     return "Finalizer";
+    case ExecutionModeSubgroupSize:                  return "SubgroupSize";
+    case ExecutionModeSubgroupsPerWorkgroup:         return "SubgroupsPerWorkgroup";
+    case ExecutionModeSubgroupsPerWorkgroupId:       return "SubgroupsPerWorkgroupId";
+    case ExecutionModeLocalSizeId:                   return "LocalSizeId";
+    case ExecutionModeLocalSizeHintId:               return "LocalSizeHintId";
 
-    case ExecutionModePostDepthCoverage:        return "PostDepthCoverage";
-    case ExecutionModeDenormPreserve:           return "DenormPreserve";
-    case ExecutionModeDenormFlushToZero:        return "DenormFlushToZero";
-    case ExecutionModeSignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve";
-    case ExecutionModeRoundingModeRTE:          return "RoundingModeRTE";
-    case ExecutionModeRoundingModeRTZ:          return "RoundingModeRTZ";
-    case ExecutionModeStencilRefReplacingEXT:   return "StencilRefReplacingEXT";
+    case ExecutionModePostDepthCoverage:             return "PostDepthCoverage";
+    case ExecutionModeDenormPreserve:                return "DenormPreserve";
+    case ExecutionModeDenormFlushToZero:             return "DenormFlushToZero";
+    case ExecutionModeSignedZeroInfNanPreserve:      return "SignedZeroInfNanPreserve";
+    case ExecutionModeRoundingModeRTE:               return "RoundingModeRTE";
+    case ExecutionModeRoundingModeRTZ:               return "RoundingModeRTZ";
+    case ExecutionModeEarlyAndLateFragmentTestsAMD:  return "EarlyAndLateFragmentTestsAMD";
+    case ExecutionModeStencilRefUnchangedFrontAMD:   return "StencilRefUnchangedFrontAMD";
+    case ExecutionModeStencilRefLessFrontAMD:        return "StencilRefLessFrontAMD";
+    case ExecutionModeStencilRefGreaterBackAMD:      return "StencilRefGreaterBackAMD";
+    case ExecutionModeStencilRefReplacingEXT:        return "StencilRefReplacingEXT";
     case ExecutionModeSubgroupUniformControlFlowKHR: return "SubgroupUniformControlFlow";
 
-    case ExecutionModeOutputLinesNV:            return "OutputLinesNV";
-    case ExecutionModeOutputPrimitivesNV:       return "OutputPrimitivesNV";
-    case ExecutionModeOutputTrianglesNV:        return "OutputTrianglesNV";
-    case ExecutionModeDerivativeGroupQuadsNV:   return "DerivativeGroupQuadsNV";
-    case ExecutionModeDerivativeGroupLinearNV:  return "DerivativeGroupLinearNV";
+    case ExecutionModeOutputLinesNV:                 return "OutputLinesNV";
+    case ExecutionModeOutputPrimitivesNV:            return "OutputPrimitivesNV";
+    case ExecutionModeOutputTrianglesNV:             return "OutputTrianglesNV";
+    case ExecutionModeDerivativeGroupQuadsNV:        return "DerivativeGroupQuadsNV";
+    case ExecutionModeDerivativeGroupLinearNV:       return "DerivativeGroupLinearNV";
 
     case ExecutionModePixelInterlockOrderedEXT:         return "PixelInterlockOrderedEXT";
     case ExecutionModePixelInterlockUnorderedEXT:       return "PixelInterlockUnorderedEXT";
@@ -238,7 +244,7 @@
     case StorageClassIncomingCallableDataKHR:  return "IncomingCallableDataKHR";
 
     case StorageClassPhysicalStorageBufferEXT: return "PhysicalStorageBufferEXT";
-
+    case StorageClassTaskPayloadWorkgroupEXT:  return "TaskPayloadWorkgroupEXT";
     default: return "Bad";
     }
 }
@@ -305,7 +311,8 @@
     case DecorationPerPrimitiveNV:              return "PerPrimitiveNV";
     case DecorationPerViewNV:                   return "PerViewNV";
     case DecorationPerTaskNV:                   return "PerTaskNV";
-    case DecorationPerVertexNV:                 return "PerVertexNV";
+    
+    case DecorationPerVertexKHR:                return "PerVertexKHR";
 
     case DecorationNonUniformEXT:           return "DecorationNonUniformEXT";
     case DecorationHlslCounterBufferGOOGLE: return "DecorationHlslCounterBufferGOOGLE";
@@ -392,6 +399,7 @@
     case BuiltInObjectRayDirectionKHR:       return "ObjectRayDirectionKHR";
     case BuiltInRayTminKHR:                  return "RayTminKHR";
     case BuiltInRayTmaxKHR:                  return "RayTmaxKHR";
+    case BuiltInCullMaskKHR:                 return "CullMaskKHR";
     case BuiltInInstanceCustomIndexKHR:      return "InstanceCustomIndexKHR";
     case BuiltInRayGeometryIndexKHR:         return "RayGeometryIndexKHR";
     case BuiltInObjectToWorldKHR:            return "ObjectToWorldKHR";
@@ -406,8 +414,8 @@
     case BuiltInViewportMaskPerViewNV:       return "ViewportMaskPerViewNV";
 //    case BuiltInFragmentSizeNV:             return "FragmentSizeNV";        // superseded by BuiltInFragSizeEXT
 //    case BuiltInInvocationsPerPixelNV:      return "InvocationsPerPixelNV"; // superseded by BuiltInFragInvocationCountEXT
-    case BuiltInBaryCoordNV:                 return "BaryCoordNV";
-    case BuiltInBaryCoordNoPerspNV:          return "BaryCoordNoPerspNV";
+    case BuiltInBaryCoordKHR:                return "BaryCoordKHR";
+    case BuiltInBaryCoordNoPerspKHR:         return "BaryCoordNoPerspKHR";
 
     case BuiltInFragSizeEXT:                 return "FragSizeEXT";
     case BuiltInFragInvocationCountEXT:      return "FragInvocationCountEXT";
@@ -427,6 +435,10 @@
     case BuiltInWarpIDNV:               return "WarpIDNV";
     case BuiltInSMIDNV:                 return "SMIDNV";
     case BuiltInCurrentRayTimeNV:       return "CurrentRayTimeNV";
+    case BuiltInPrimitivePointIndicesEXT:        return "PrimitivePointIndicesEXT";
+    case BuiltInPrimitiveLineIndicesEXT:         return "PrimitiveLineIndicesEXT";
+    case BuiltInPrimitiveTriangleIndicesEXT:     return "PrimitiveTriangleIndicesEXT";
+    case BuiltInCullPrimitiveEXT:                return "CullPrimitiveEXT";
 
     default: return "Bad";
     }
@@ -900,6 +912,12 @@
     case CapabilityDeviceGroup: return "DeviceGroup";
     case CapabilityMultiView:   return "MultiView";
 
+    case CapabilityDenormPreserve:           return "DenormPreserve";
+    case CapabilityDenormFlushToZero:        return "DenormFlushToZero";
+    case CapabilitySignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve";
+    case CapabilityRoundingModeRTE:          return "RoundingModeRTE";
+    case CapabilityRoundingModeRTZ:          return "RoundingModeRTZ";
+
     case CapabilityStencilExportEXT: return "StencilExportEXT";
 
     case CapabilityFloat16ImageAMD:       return "Float16ImageAMD";
@@ -919,14 +937,16 @@
     case CapabilityRayTracingNV:                    return "RayTracingNV";
     case CapabilityRayTracingMotionBlurNV:          return "RayTracingMotionBlurNV";
     case CapabilityRayTracingKHR:                   return "RayTracingKHR";
+    case CapabilityRayCullMaskKHR:                  return "RayCullMaskKHR";
     case CapabilityRayQueryKHR:                     return "RayQueryKHR";
     case CapabilityRayTracingProvisionalKHR:        return "RayTracingProvisionalKHR";
     case CapabilityRayTraversalPrimitiveCullingKHR: return "RayTraversalPrimitiveCullingKHR";
     case CapabilityComputeDerivativeGroupQuadsNV:   return "ComputeDerivativeGroupQuadsNV";
     case CapabilityComputeDerivativeGroupLinearNV:  return "ComputeDerivativeGroupLinearNV";
-    case CapabilityFragmentBarycentricNV:           return "FragmentBarycentricNV";
+    case CapabilityFragmentBarycentricKHR:          return "FragmentBarycentricKHR";
     case CapabilityMeshShadingNV:                   return "MeshShadingNV";
     case CapabilityImageFootprintNV:                return "ImageFootprintNV";
+    case CapabilityMeshShadingEXT:                  return "MeshShadingEXT";
 //    case CapabilityShadingRateNV:                   return "ShadingRateNV";  // superseded by FragmentDensityEXT
     case CapabilitySampleMaskOverrideCoverageNV:    return "SampleMaskOverrideCoverageNV";
     case CapabilityFragmentDensityEXT:              return "FragmentDensityEXT";
@@ -1394,6 +1414,8 @@
     case OpGroupNonUniformPartitionNV:       return "OpGroupNonUniformPartitionNV";
     case OpImageSampleFootprintNV:           return "OpImageSampleFootprintNV";
     case OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV";
+    case OpEmitMeshTasksEXT:                 return "OpEmitMeshTasksEXT";
+    case OpSetMeshOutputsEXT:                return "OpSetMeshOutputsEXT";
 
     case OpTypeRayQueryKHR:                                                   return "OpTypeRayQueryKHR";
     case OpRayQueryInitializeKHR:                                             return "OpRayQueryInitializeKHR";
@@ -2968,6 +2990,17 @@
     InstructionDesc[OpWritePackedPrimitiveIndices4x8NV].operands.push(OperandId, "'Index Offset'");
     InstructionDesc[OpWritePackedPrimitiveIndices4x8NV].operands.push(OperandId, "'Packed Indices'");
 
+    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[OpSetMeshOutputsEXT].operands.push(OperandId, "'vertexCount'");
+    InstructionDesc[OpSetMeshOutputsEXT].operands.push(OperandId, "'primitiveCount'");
+    InstructionDesc[OpSetMeshOutputsEXT].setResultAndType(false, false);
+
+
     InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Component Type'");
     InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Scope'");
     InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Rows'");
diff --git a/SPIRV/spirv.hpp b/SPIRV/spirv.hpp
index f6b7be9..0e40544 100644
--- a/SPIRV/spirv.hpp
+++ b/SPIRV/spirv.hpp
@@ -1,2314 +1,2533 @@
-// 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 0x10500
-#define SPV_REVISION 4
-
-static const unsigned int MagicNumber = 0x07230203;
-static const unsigned int Version = 0x00010500;
-static const unsigned int Revision = 4;
-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,
-    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,
-    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,
-    ExecutionModeStencilRefReplacingEXT = 5027,
-    ExecutionModeOutputLinesNV = 5269,
-    ExecutionModeOutputPrimitivesNV = 5270,
-    ExecutionModeDerivativeGroupQuadsNV = 5289,
-    ExecutionModeDerivativeGroupLinearNV = 5290,
-    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,
-    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,
-    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,
-};
-
-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,
-    DecorationPerPrimitiveNV = 5271,
-    DecorationPerViewNV = 5272,
-    DecorationPerTaskNV = 5273,
-    DecorationPerVertexNV = 5285,
-    DecorationNonUniform = 5300,
-    DecorationNonUniformEXT = 5300,
-    DecorationRestrictPointer = 5355,
-    DecorationRestrictPointerEXT = 5355,
-    DecorationAliasedPointer = 5356,
-    DecorationAliasedPointerEXT = 5356,
-    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,
-    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,
-    BuiltInBaryCoordNV = 5286,
-    BuiltInBaryCoordNoPerspNV = 5287,
-    BuiltInFragSizeEXT = 5292,
-    BuiltInFragmentSizeNV = 5292,
-    BuiltInFragInvocationCountEXT = 5293,
-    BuiltInInvocationsPerPixelNV = 5293,
-    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,
-    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,
-    FunctionControlMax = 0x7fffffff,
-};
-
-enum FunctionControlMask {
-    FunctionControlMaskNone = 0,
-    FunctionControlInlineMask = 0x00000001,
-    FunctionControlDontInlineMask = 0x00000002,
-    FunctionControlPureMask = 0x00000004,
-    FunctionControlConstMask = 0x00000008,
-};
-
-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,
-    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,
-    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,
-    CapabilityDemoteToHelperInvocationEXT = 5379,
-    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,
-    CapabilityUnstructuredLoopControlsINTEL = 5886,
-    CapabilityFPGALoopControlsINTEL = 5888,
-    CapabilityKernelAttributesINTEL = 5892,
-    CapabilityFPGAKernelAttributesINTEL = 5897,
-    CapabilityFPGAMemoryAccessesINTEL = 5898,
-    CapabilityFPGAClusterAttributesINTEL = 5904,
-    CapabilityLoopFuseINTEL = 5906,
-    CapabilityFPGABufferLocationINTEL = 5920,
-    CapabilityUSMStorageClassesINTEL = 5935,
-    CapabilityIOPipesINTEL = 5943,
-    CapabilityBlockingPipesINTEL = 5945,
-    CapabilityFPGARegINTEL = 5948,
-    CapabilityAtomicFloat32AddEXT = 6033,
-    CapabilityAtomicFloat64AddEXT = 6034,
-    CapabilityLongConstantCompositeINTEL = 6089,
-    CapabilityAtomicFloat16AddEXT = 6095,
-    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 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,
-    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,
-    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,
-    OpDemoteToHelperInvocationEXT = 5380,
-    OpIsHelperInvocationEXT = 5381,
-    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,
-    OpLoopControlINTEL = 5887,
-    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 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 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 OpDemoteToHelperInvocationEXT: *hasResult = false; *hasResultType = false; break;
-    case OpIsHelperInvocationEXT: *hasResult = true; *hasResultType = true; 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 OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcRefConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicInitializeINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicConfigureSkcINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicConfigureIpeLumaINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicConfigureIpeLumaChromaINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicGetMotionVectorMaskINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicEvaluateIpeINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicGetIpeLumaShapeINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicGetPackedIpeLumaModesINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicGetIpeChromaModeINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicGetInterRawSadsINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpVariableLengthArrayINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSaveMemoryINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpRestoreMemoryINTEL: *hasResult = false; *hasResultType = false; break;
-    case OpLoopControlINTEL: *hasResult = false; *hasResultType = false; break;
-    case OpPtrCastToCrossWorkgroupINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpCrossWorkgroupCastToPtrINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpReadPipeBlockingINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpWritePipeBlockingINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFPGARegINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetRayTMinKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetRayFlagsKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionTKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionInstanceCustomIndexKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionInstanceIdKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionGeometryIndexKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionPrimitiveIndexKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionBarycentricsKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionFrontFaceKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionObjectRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionObjectRayOriginKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetWorldRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetWorldRayOriginKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break;
-    case OpAtomicFAddEXT: *hasResult = true; *hasResultType = true; break;
-    case OpTypeBufferSurfaceINTEL: *hasResult = true; *hasResultType = false; break;
-    case OpTypeStructContinuedINTEL: *hasResult = false; *hasResultType = false; break;
-    case OpConstantCompositeContinuedINTEL: *hasResult = false; *hasResultType = false; break;
-    case OpSpecConstantCompositeContinuedINTEL: *hasResult = false; *hasResultType = false; break;
-    }
-}
-#endif /* SPV_ENABLE_UTILITY_CODE */
-
-// Overload operator| for mask bit combining
-
-inline ImageOperandsMask operator|(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) | unsigned(b)); }
-inline FPFastMathModeMask operator|(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) | unsigned(b)); }
-inline SelectionControlMask operator|(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) | unsigned(b)); }
-inline LoopControlMask operator|(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) | unsigned(b)); }
-inline FunctionControlMask operator|(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) | unsigned(b)); }
-inline MemorySemanticsMask operator|(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) | unsigned(b)); }
-inline MemoryAccessMask operator|(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) | unsigned(b)); }
-inline KernelProfilingInfoMask operator|(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) | unsigned(b)); }
-inline RayFlagsMask operator|(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) | unsigned(b)); }
-inline FragmentShadingRateMask operator|(FragmentShadingRateMask a, FragmentShadingRateMask b) { return FragmentShadingRateMask(unsigned(a) | unsigned(b)); }
-
-}  // end namespace spv
-
-#endif  // #ifndef spirv_HPP
-
+// 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 OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcRefConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicInitializeINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicConfigureSkcINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicConfigureIpeLumaINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicConfigureIpeLumaChromaINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicGetMotionVectorMaskINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicEvaluateIpeINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicGetIpeLumaShapeINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicGetPackedIpeLumaModesINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicGetIpeChromaModeINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSubgroupAvcSicGetInterRawSadsINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpVariableLengthArrayINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpSaveMemoryINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpRestoreMemoryINTEL: *hasResult = false; *hasResultType = false; break;

+    case OpArbitraryFloatSinCosPiINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatCastINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatCastFromIntINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatCastToIntINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatAddINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatSubINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatMulINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatDivINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatGTINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatGEINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatLTINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatLEINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatEQINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatRecipINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatRSqrtINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatCbrtINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatHypotINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatSqrtINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatLogINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatLog2INTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatLog10INTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatLog1pINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatExpINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatExp2INTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatExp10INTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatExpm1INTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatSinINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatCosINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatSinCosINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatSinPiINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatCosPiINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatASinINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatASinPiINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatACosINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatACosPiINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatATanINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatATanPiINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatATan2INTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatPowINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatPowRINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpArbitraryFloatPowNINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpLoopControlINTEL: *hasResult = false; *hasResultType = false; break;

+    case OpFixedSqrtINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpFixedRecipINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpFixedRsqrtINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpFixedSinINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpFixedCosINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpFixedSinCosINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpFixedSinPiINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpFixedCosPiINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpFixedSinCosPiINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpFixedLogINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpFixedExpINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpPtrCastToCrossWorkgroupINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpCrossWorkgroupCastToPtrINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpReadPipeBlockingINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpWritePipeBlockingINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpFPGARegINTEL: *hasResult = true; *hasResultType = true; break;

+    case OpRayQueryGetRayTMinKHR: *hasResult = true; *hasResultType = true; break;

+    case OpRayQueryGetRayFlagsKHR: *hasResult = true; *hasResultType = true; break;

+    case OpRayQueryGetIntersectionTKHR: *hasResult = true; *hasResultType = true; break;

+    case OpRayQueryGetIntersectionInstanceCustomIndexKHR: *hasResult = true; *hasResultType = true; break;

+    case OpRayQueryGetIntersectionInstanceIdKHR: *hasResult = true; *hasResultType = true; break;

+    case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: *hasResult = true; *hasResultType = true; break;

+    case OpRayQueryGetIntersectionGeometryIndexKHR: *hasResult = true; *hasResultType = true; break;

+    case OpRayQueryGetIntersectionPrimitiveIndexKHR: *hasResult = true; *hasResultType = true; break;

+    case OpRayQueryGetIntersectionBarycentricsKHR: *hasResult = true; *hasResultType = true; break;

+    case OpRayQueryGetIntersectionFrontFaceKHR: *hasResult = true; *hasResultType = true; break;

+    case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: *hasResult = true; *hasResultType = true; break;

+    case OpRayQueryGetIntersectionObjectRayDirectionKHR: *hasResult = true; *hasResultType = true; break;

+    case OpRayQueryGetIntersectionObjectRayOriginKHR: *hasResult = true; *hasResultType = true; break;

+    case OpRayQueryGetWorldRayDirectionKHR: *hasResult = true; *hasResultType = true; break;

+    case OpRayQueryGetWorldRayOriginKHR: *hasResult = true; *hasResultType = true; break;

+    case OpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break;

+    case OpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break;

+    case OpAtomicFAddEXT: *hasResult = true; *hasResultType = true; break;

+    case OpTypeBufferSurfaceINTEL: *hasResult = true; *hasResultType = false; break;

+    case OpTypeStructContinuedINTEL: *hasResult = false; *hasResultType = false; break;

+    case OpConstantCompositeContinuedINTEL: *hasResult = false; *hasResultType = false; break;

+    case OpSpecConstantCompositeContinuedINTEL: *hasResult = false; *hasResultType = false; break;

+    }

+}

+#endif /* SPV_ENABLE_UTILITY_CODE */

+

+// Overload operator| for mask bit combining

+

+inline ImageOperandsMask operator|(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) | unsigned(b)); }

+inline FPFastMathModeMask operator|(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) | unsigned(b)); }

+inline SelectionControlMask operator|(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) | unsigned(b)); }

+inline LoopControlMask operator|(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) | unsigned(b)); }

+inline FunctionControlMask operator|(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) | unsigned(b)); }

+inline MemorySemanticsMask operator|(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) | unsigned(b)); }

+inline MemoryAccessMask operator|(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) | unsigned(b)); }

+inline KernelProfilingInfoMask operator|(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) | unsigned(b)); }

+inline RayFlagsMask operator|(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) | unsigned(b)); }

+inline FragmentShadingRateMask operator|(FragmentShadingRateMask a, FragmentShadingRateMask b) { return FragmentShadingRateMask(unsigned(a) | unsigned(b)); }

+

+}  // end namespace spv

+

+#endif  // #ifndef spirv_HPP

diff --git a/SPIRV/spvIR.h b/SPIRV/spvIR.h
index 486e80d..0969127 100644
--- a/SPIRV/spvIR.h
+++ b/SPIRV/spvIR.h
@@ -111,27 +111,23 @@
 
     void addStringOperand(const char* str)
     {
-        unsigned int word;
-        char* wordString = (char*)&word;
-        char* wordPtr = wordString;
-        int charCount = 0;
+        unsigned int word = 0;
+        unsigned int shiftAmount = 0;
         char c;
+
         do {
             c = *(str++);
-            *(wordPtr++) = c;
-            ++charCount;
-            if (charCount == 4) {
+            word |= ((unsigned int)c) << shiftAmount;
+            shiftAmount += 8;
+            if (shiftAmount == 32) {
                 addImmediateOperand(word);
-                wordPtr = wordString;
-                charCount = 0;
+                word = 0;
+                shiftAmount = 0;
             }
         } while (c != 0);
 
         // deal with partial last word
-        if (charCount > 0) {
-            // pad with 0s
-            for (; charCount < 4; ++charCount)
-                *(wordPtr++) = 0;
+        if (shiftAmount > 0) {
             addImmediateOperand(word);
         }
     }
@@ -353,6 +349,7 @@
     const std::vector<Block*>& getBlocks() const { return blocks; }
     void addLocalVariable(std::unique_ptr<Instruction> inst);
     Id getReturnType() const { return functionInstruction.getTypeId(); }
+    Id getFuncId() const { return functionInstruction.getResultId(); }
     void setReturnPrecision(Decoration precision)
     {
         if (precision == DecorationRelaxedPrecision)
@@ -361,6 +358,14 @@
     Decoration getReturnPrecision() const
         { return reducedPrecisionReturn ? DecorationRelaxedPrecision : NoPrecision; }
 
+    void setDebugLineInfo(Id fileName, int line, int column) {
+        lineInstruction = std::unique_ptr<Instruction>{new Instruction(OpLine)};
+        lineInstruction->addIdOperand(fileName);
+        lineInstruction->addImmediateOperand(line);
+        lineInstruction->addImmediateOperand(column);
+    }
+    bool hasDebugLineInfo() const { return lineInstruction != nullptr; }
+
     void setImplicitThis() { implicitThis = true; }
     bool hasImplicitThis() const { return implicitThis; }
 
@@ -377,6 +382,11 @@
 
     void dump(std::vector<unsigned int>& out) const
     {
+        // OpLine
+        if (lineInstruction != nullptr) {
+            lineInstruction->dump(out);
+        }
+        
         // OpFunction
         functionInstruction.dump(out);
 
@@ -395,6 +405,7 @@
     Function& operator=(Function&);
 
     Module& parent;
+    std::unique_ptr<Instruction> lineInstruction;
     Instruction functionInstruction;
     std::vector<Instruction*> parameterInstructions;
     std::vector<Block*> blocks;
@@ -461,7 +472,8 @@
 // - the OpFunction instruction
 // - all the OpFunctionParameter instructions
 __inline Function::Function(Id id, Id resultType, Id functionType, Id firstParamId, Module& parent)
-    : parent(parent), functionInstruction(id, resultType, OpFunction), implicitThis(false),
+    : parent(parent), lineInstruction(nullptr),
+      functionInstruction(id, resultType, OpFunction), implicitThis(false),
       reducedPrecisionReturn(false)
 {
     // OpFunction
diff --git a/StandAlone/CMakeLists.txt b/StandAlone/CMakeLists.txt
index 2b163e7..d54a1df 100644
--- a/StandAlone/CMakeLists.txt
+++ b/StandAlone/CMakeLists.txt
@@ -104,24 +104,48 @@
 endif()
 
 if(ENABLE_GLSLANG_INSTALL)
-    install(TARGETS glslangValidator EXPORT glslangValidatorTargets
-            RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-    install(EXPORT glslangValidatorTargets DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
+    install(TARGETS glslangValidator EXPORT glslang-targets)
+
+    # Backward compatibility
+    file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/glslangValidatorTargets.cmake" "
+        message(WARNING \"Using `glslangValidatorTargets.cmake` is deprecated: use `find_package(glslang)` to find glslang CMake targets.\")
+
+        if (NOT TARGET glslang::glslangValidator)
+            include(\"\${CMAKE_CURRENT_LIST_DIR}/../../${CMAKE_INSTALL_LIBDIR}/${PROJECT_NAME}/glslang-targets.cmake\")
+        endif()
+
+        add_library(glslangValidator ALIAS glslang::glslangValidator)
+    ")
+    install(FILES "${CMAKE_CURRENT_BINARY_DIR}/glslangValidatorTargets.cmake" DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
 
     if(ENABLE_SPVREMAPPER)
-        install(TARGETS spirv-remap EXPORT spirv-remapTargets
-            RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-        install(EXPORT spirv-remapTargets DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
+        install(TARGETS spirv-remap EXPORT glslang-targets)
+
+        # Backward compatibility
+        file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/spirv-remapTargets.cmake" "
+            message(WARNING \"Using `spirv-remapTargets.cmake` is deprecated: use `find_package(glslang)` to find glslang CMake targets.\")
+
+            if (NOT TARGET glslang::spirv-remap)
+                include(\"\${CMAKE_CURRENT_LIST_DIR}/../../${CMAKE_INSTALL_LIBDIR}/${PROJECT_NAME}/glslang-targets.cmake\")
+            endif()
+
+            add_library(spirv-remap ALIAS glslang::spirv-remap)
+        ")
+        install(FILES "${CMAKE_CURRENT_BINARY_DIR}/spirv-remapTargets.cmake" DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
     endif()
 
-    if(BUILD_SHARED_LIBS)
-        install(TARGETS glslang-default-resource-limits EXPORT glslang-default-resource-limitsTargets
-                ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-                LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-                RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-    else()
-        install(TARGETS glslang-default-resource-limits EXPORT glslang-default-resource-limitsTargets
-                ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-    endif()
-    install(EXPORT glslang-default-resource-limitsTargets DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
+    install(TARGETS glslang-default-resource-limits EXPORT glslang-targets)
+
+    # Backward compatibility
+    file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/glslang-default-resource-limitsTargets.cmake" "
+        message(WARNING \"Using `glslang-default-resource-limitsTargets.cmake` is deprecated: use `find_package(glslang)` to find glslang CMake targets.\")
+
+        if (NOT TARGET glslang::glslang-default-resource-limits)
+            include(\"\${CMAKE_CURRENT_LIST_DIR}/../../${CMAKE_INSTALL_LIBDIR}/${PROJECT_NAME}/glslang-targets.cmake\")
+        endif()
+
+        add_library(glslang-default-resource-limits ALIAS glslang::glslang-default-resource-limits)
+    ")
+    install(FILES "${CMAKE_CURRENT_BINARY_DIR}/glslang-default-resource-limitsTargets.cmake" DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
+
 endif()
diff --git a/StandAlone/ResourceLimits.cpp b/StandAlone/ResourceLimits.cpp
index 7c7f4c4..1a76bf6 100644
--- a/StandAlone/ResourceLimits.cpp
+++ b/StandAlone/ResourceLimits.cpp
@@ -134,6 +134,15 @@
     /* .maxTaskWorkGroupSizeY_NV = */ 1,
     /* .maxTaskWorkGroupSizeZ_NV = */ 1,
     /* .maxMeshViewCountNV = */ 4,
+    /* .maxMeshOutputVerticesEXT = */ 256,
+    /* .maxMeshOutputPrimitivesEXT = */ 256,
+    /* .maxMeshWorkGroupSizeX_EXT = */ 128,
+    /* .maxMeshWorkGroupSizeY_EXT = */ 128,
+    /* .maxMeshWorkGroupSizeZ_EXT = */ 128,
+    /* .maxTaskWorkGroupSizeX_EXT = */ 128,
+    /* .maxTaskWorkGroupSizeY_EXT = */ 128,
+    /* .maxTaskWorkGroupSizeZ_EXT = */ 128,
+    /* .maxMeshViewCountEXT = */ 4,
     /* .maxDualSourceDrawBuffersEXT = */ 1,
 
     /* .limits = */ {
@@ -244,6 +253,15 @@
             << "MaxTaskWorkGroupSizeY_NV "                  << DefaultTBuiltInResource.maxTaskWorkGroupSizeY_NV << "\n"
             << "MaxTaskWorkGroupSizeZ_NV "                  << DefaultTBuiltInResource.maxTaskWorkGroupSizeZ_NV << "\n"
             << "MaxMeshViewCountNV "                        << DefaultTBuiltInResource.maxMeshViewCountNV << "\n"
+            << "MaxMeshOutputVerticesEXT "                  << DefaultTBuiltInResource.maxMeshOutputVerticesEXT << "\n"
+            << "MaxMeshOutputPrimitivesEXT "                << DefaultTBuiltInResource.maxMeshOutputPrimitivesEXT << "\n"
+            << "MaxMeshWorkGroupSizeX_EXT "                 << DefaultTBuiltInResource.maxMeshWorkGroupSizeX_EXT << "\n"
+            << "MaxMeshWorkGroupSizeY_EXT "                 << DefaultTBuiltInResource.maxMeshWorkGroupSizeY_EXT << "\n"
+            << "MaxMeshWorkGroupSizeZ_EXT "                 << DefaultTBuiltInResource.maxMeshWorkGroupSizeZ_EXT << "\n"
+            << "MaxTaskWorkGroupSizeX_EXT "                 << DefaultTBuiltInResource.maxTaskWorkGroupSizeX_EXT << "\n"
+            << "MaxTaskWorkGroupSizeY_EXT "                 << DefaultTBuiltInResource.maxTaskWorkGroupSizeY_EXT << "\n"
+            << "MaxTaskWorkGroupSizeZ_EXT "                 << DefaultTBuiltInResource.maxTaskWorkGroupSizeZ_EXT << "\n"
+            << "MaxMeshViewCountEXT "                       << DefaultTBuiltInResource.maxMeshViewCountEXT << "\n"
             << "MaxDualSourceDrawBuffersEXT "               << DefaultTBuiltInResource.maxDualSourceDrawBuffersEXT << "\n"
             << "nonInductiveForLoops "                      << DefaultTBuiltInResource.limits.nonInductiveForLoops << "\n"
             << "whileLoops "                                << DefaultTBuiltInResource.limits.whileLoops << "\n"
@@ -469,6 +487,24 @@
             resources->maxTaskWorkGroupSizeZ_NV = value;
         else if (tokenStr == "MaxMeshViewCountNV")
             resources->maxMeshViewCountNV = value;
+        else if (tokenStr == "MaxMeshOutputVerticesEXT")
+            resources->maxMeshOutputVerticesEXT = value;
+        else if (tokenStr == "MaxMeshOutputPrimitivesEXT")
+            resources->maxMeshOutputPrimitivesEXT = value;
+        else if (tokenStr == "MaxMeshWorkGroupSizeX_EXT")
+            resources->maxMeshWorkGroupSizeX_EXT = value;
+        else if (tokenStr == "MaxMeshWorkGroupSizeY_EXT")
+            resources->maxMeshWorkGroupSizeY_EXT = value;
+        else if (tokenStr == "MaxMeshWorkGroupSizeZ_EXT")
+            resources->maxMeshWorkGroupSizeZ_EXT = value;
+        else if (tokenStr == "MaxTaskWorkGroupSizeX_EXT")
+            resources->maxTaskWorkGroupSizeX_EXT = value;
+        else if (tokenStr == "MaxTaskWorkGroupSizeY_EXT")
+            resources->maxTaskWorkGroupSizeY_EXT = value;
+        else if (tokenStr == "MaxTaskWorkGroupSizeZ_EXT")
+            resources->maxTaskWorkGroupSizeZ_EXT = value;
+        else if (tokenStr == "MaxMeshViewCountEXT")
+            resources->maxMeshViewCountEXT = value;
         else if (tokenStr == "nonInductiveForLoops")
             resources->limits.nonInductiveForLoops = (value != 0);
         else if (tokenStr == "whileLoops")
diff --git a/StandAlone/StandAlone.cpp b/StandAlone/StandAlone.cpp
index 23e510c..edde81e 100644
--- a/StandAlone/StandAlone.cpp
+++ b/StandAlone/StandAlone.cpp
@@ -113,6 +113,8 @@
 bool SpvToolsValidate = false;
 bool NaNClamp = false;
 bool stripDebugInfo = false;
+bool emitNonSemanticShaderDebugInfo = false;
+bool emitNonSemanticShaderDebugSource = false;
 bool beQuiet = false;
 bool VulkanRulesRelaxed = false;
 bool autoSampledTextures = false;
@@ -177,6 +179,8 @@
 const char* variableName = nullptr;
 bool HlslEnable16BitTypes = false;
 bool HlslDX9compatible = false;
+bool HlslDxPositionW = false;
+bool EnhancedMsgs = false;
 bool DumpBuiltinSymbols = false;
 std::vector<std::string> IncludeDirectoryList;
 
@@ -190,6 +194,9 @@
 glslang::EShTargetLanguage TargetLanguage = glslang::EShTargetNone;
 glslang::EShTargetLanguageVersion TargetVersion;     // not valid until TargetLanguage is set
 
+// GLSL version
+int GlslVersion = 0; // GLSL version specified on CLI, overrides #version in shader source
+
 std::vector<std::string> Processes;                     // what should be recorded by OpModuleProcessed, or equivalent
 
 // Per descriptor-set binding base data
@@ -288,8 +295,8 @@
         case EShLangClosestHit:      name = "rchit.spv";   break;
         case EShLangMiss:            name = "rmiss.spv";   break;
         case EShLangCallable:        name = "rcall.spv";   break;
-        case EShLangMeshNV:          name = "mesh.spv";    break;
-        case EShLangTaskNV:          name = "task.spv";    break;
+        case EShLangMesh :           name = "mesh.spv";    break;
+        case EShLangTask :           name = "task.spv";    break;
         default:                     name = "unknown";     break;
         }
     } else
@@ -652,6 +659,48 @@
                                lowerword == "flatten-uniform-array"  ||
                                lowerword == "fua") {
                         Options |= EOptionFlattenUniformArrays;
+                    } else if (lowerword == "glsl-version") {
+                        if (argc > 1) {
+                            if (strcmp(argv[1], "100") == 0) {
+                                GlslVersion = 100;
+                            } else if (strcmp(argv[1], "110") == 0) {
+                                GlslVersion = 110;
+                            } else if (strcmp(argv[1], "120") == 0) {
+                                GlslVersion = 120;
+                            } else if (strcmp(argv[1], "130") == 0) {
+                                GlslVersion = 130;
+                            } else if (strcmp(argv[1], "140") == 0) {
+                                GlslVersion = 140;
+                            } else if (strcmp(argv[1], "150") == 0) {
+                                GlslVersion = 150;
+                            } else if (strcmp(argv[1], "300es") == 0) {
+                                GlslVersion = 300;
+                            } else if (strcmp(argv[1], "310es") == 0) {
+                                GlslVersion = 310;
+                            } else if (strcmp(argv[1], "320es") == 0) {
+                                GlslVersion = 320;
+                            } else if (strcmp(argv[1], "330") == 0) {
+                                GlslVersion = 330;
+                            } else if (strcmp(argv[1], "400") == 0) {
+                                GlslVersion = 400;
+                            } else if (strcmp(argv[1], "410") == 0) {
+                                GlslVersion = 410;
+                            } else if (strcmp(argv[1], "420") == 0) {
+                                GlslVersion = 420;
+                            } else if (strcmp(argv[1], "430") == 0) {
+                                GlslVersion = 430;
+                            } else if (strcmp(argv[1], "440") == 0) {
+                                GlslVersion = 440;
+                            } else if (strcmp(argv[1], "450") == 0) {
+                                GlslVersion = 450;
+                            } else if (strcmp(argv[1], "460") == 0) {
+                                GlslVersion = 460;
+                            } else
+                                Error("--glsl-version expected one of: 100, 110, 120, 130, 140, 150,\n"
+                                      "300es, 310es, 320es, 330\n"
+                                      "400, 410, 420, 430, 440, 450, 460");
+                        }
+                        bumpArg();
                     } else if (lowerword == "hlsl-offsets") {
                         Options |= EOptionHlslOffsets;
                     } else if (lowerword == "hlsl-iomap" ||
@@ -662,6 +711,10 @@
                         HlslEnable16BitTypes = true;
                     } else if (lowerword == "hlsl-dx9-compatible") {
                         HlslDX9compatible = true;
+                    } else if (lowerword == "hlsl-dx-position-w") {
+                        HlslDxPositionW = true;
+                    } else if (lowerword == "enhanced-msgs") {
+                        EnhancedMsgs = true;
                     } else if (lowerword == "auto-sampled-textures") { 
                         autoSampledTextures = true;
                     } else if (lowerword == "invert-y" ||  // synonyms
@@ -764,6 +817,9 @@
                             } else if (strcmp(argv[1], "vulkan1.2") == 0) {
                                 setVulkanSpv();
                                 ClientVersion = glslang::EShTargetVulkan_1_2;
+                            } else if (strcmp(argv[1], "vulkan1.3") == 0) {
+                                setVulkanSpv();
+                                ClientVersion = glslang::EShTargetVulkan_1_3;
                             } else if (strcmp(argv[1], "opengl") == 0) {
                                 setOpenGlSpv();
                                 ClientVersion = glslang::EShTargetOpenGL_450;
@@ -785,9 +841,13 @@
                             } else if (strcmp(argv[1], "spirv1.5") == 0) {
                                 TargetLanguage = glslang::EShTargetSpv;
                                 TargetVersion = glslang::EShTargetSpv_1_5;
+                            } else if (strcmp(argv[1], "spirv1.6") == 0) {
+                                TargetLanguage = glslang::EShTargetSpv;
+                                TargetVersion = glslang::EShTargetSpv_1_6;
                             } else
-                                Error("--target-env expected one of: vulkan1.0, vulkan1.1, vulkan1.2, opengl,\n"
-                                      "spirv1.0, spirv1.1, spirv1.2, spirv1.3, spirv1.4, or spirv1.5");
+                                Error("--target-env expected one of: vulkan1.0, vulkan1.1, vulkan1.2,\n"
+                                      "vulkan1.3, opengl, spirv1.0, spirv1.1, spirv1.2, spirv1.3,\n"
+                                      "spirv1.4, spirv1.5 or spirv1.6");
                         }
                         bumpArg();
                     } else if (lowerword == "undef-macro" ||
@@ -911,11 +971,21 @@
             case 'g':
                 // Override previous -g or -g0 argument
                 stripDebugInfo = false;
+                emitNonSemanticShaderDebugInfo = false;
                 Options &= ~EOptionDebug;
                 if (argv[0][2] == '0')
                     stripDebugInfo = true;
-                else
+                else {
                     Options |= EOptionDebug;
+                    if (argv[0][2] == 'V') {
+                        emitNonSemanticShaderDebugInfo = true;
+                        if (argv[0][3] == 'S') {
+                            emitNonSemanticShaderDebugSource = true;
+                        } else {
+                            emitNonSemanticShaderDebugSource = false;
+                        }
+                    }
+                }
                 break;
             case 'h':
                 usage();
@@ -1012,6 +1082,10 @@
             TargetLanguage = glslang::EShTargetSpv;
             TargetVersion = glslang::EShTargetSpv_1_5;
             break;
+        case glslang::EShTargetVulkan_1_3:
+            TargetLanguage = glslang::EShTargetSpv;
+            TargetVersion = glslang::EShTargetSpv_1_6;
+            break;
         case glslang::EShTargetOpenGL_450:
             TargetLanguage = glslang::EShTargetSpv;
             TargetVersion = glslang::EShTargetSpv_1_0;
@@ -1059,6 +1133,8 @@
         messages = (EShMessages)(messages | EShMsgHlslDX9Compatible);
     if (DumpBuiltinSymbols)
         messages = (EShMessages)(messages | EShMsgBuiltinSymbolTable);
+    if (EnhancedMsgs)
+        messages = (EShMessages)(messages | EShMsgEnhanced);
 }
 
 //
@@ -1149,6 +1225,27 @@
     }
 };
 
+// Writes a string into a depfile, escaping some special characters following the Makefile rules.
+static void writeEscapedDepString(std::ofstream& file, const std::string& str)
+{
+    for (char c : str) {
+        switch (c) {
+        case ' ':
+        case ':':
+        case '#':
+        case '[':
+        case ']':
+        case '\\':
+            file << '\\';
+            break;
+        case '$':
+            file << '$';
+            break;
+        }
+        file << c;
+    }
+}
+
 // Writes a depfile similar to gcc -MMD foo.c
 bool writeDepFile(std::string depfile, std::vector<std::string>& binaryFiles, const std::vector<std::string>& sources)
 {
@@ -1156,10 +1253,12 @@
     if (file.fail())
         return false;
 
-    for (auto it = binaryFiles.begin(); it != binaryFiles.end(); it++) {
-        file << *it << ":";
-        for (auto it = sources.begin(); it != sources.end(); it++) {
-            file << " " << *it;
+    for (auto binaryFile = binaryFiles.begin(); binaryFile != binaryFiles.end(); binaryFile++) {
+        writeEscapedDepString(file, *binaryFile);
+        file << ":";
+        for (auto sourceFile = sources.begin(); sourceFile != sources.end(); sourceFile++) {
+            file << " ";
+            writeEscapedDepString(file, *sourceFile);
         }
         file << std::endl;
     }
@@ -1209,6 +1308,8 @@
             shader->setSourceEntryPoint(sourceEntryPointName);
         }
 
+        shader->setOverrideVersion(GlslVersion);
+
         std::string intrinsicString = getIntrinsic(compUnit.text, compUnit.count);
 
         PreambleString = "";
@@ -1284,6 +1385,15 @@
         if (Options & EOptionInvertY)
             shader->setInvertY(true);
 
+        if (HlslDxPositionW)
+            shader->setDxPositionW(true);
+
+        if (EnhancedMsgs)
+            shader->setEnhancedMsgs();
+
+        if (emitNonSemanticShaderDebugInfo)
+            shader->setDebugInfo(true);
+
         // Set up the environment, some subsettings take precedence over earlier
         // ways of setting things.
         if (Options & EOptionSpv) {
@@ -1375,9 +1485,15 @@
                     std::vector<unsigned int> spirv;
                     spv::SpvBuildLogger logger;
                     glslang::SpvOptions spvOptions;
-                    if (Options & EOptionDebug)
+                    if (Options & EOptionDebug) {
                         spvOptions.generateDebugInfo = true;
-                    else if (stripDebugInfo)
+                        if (emitNonSemanticShaderDebugInfo) {
+                            spvOptions.emitNonSemanticShaderDebugInfo = true;
+                            if (emitNonSemanticShaderDebugSource) {
+                                spvOptions.emitNonSemanticShaderDebugSource = true;
+                            }
+                        }
+                    } else if (stripDebugInfo)
                         spvOptions.stripDebugInfo = true;
                     spvOptions.disableOptimizer = (Options & EOptionOptimizeDisable) != 0;
                     spvOptions.optimizeSize = (Options & EOptionOptimizeSize) != 0;
@@ -1685,9 +1801,9 @@
     else if (stageName == "rcall")
         return EShLangCallable;
     else if (stageName == "mesh")
-        return EShLangMeshNV;
+        return EShLangMesh;
     else if (stageName == "task")
-        return EShLangTaskNV;
+        return EShLangTask;
 
     usage();
     return EShLangVertex;
@@ -1811,6 +1927,8 @@
            "              SPV_GOOGLE_hlsl_functionality1 extension\n"
            "  -g          generate debug information\n"
            "  -g0         strip debug information\n"
+           "  -gV         generate nonsemantic shader debug information\n"
+           "  -gVS        generate nonsemantic shader debug information with source\n"
            "  -h          print this usage message\n"
            "  -i          intermediate tree (glslang AST) is printed out\n"
            "  -l          link all input files together to form a single module\n"
@@ -1840,6 +1958,11 @@
            "  -dumpfullversion | -dumpversion   print bare major.minor.patchlevel\n"
            "  --flatten-uniform-arrays | --fua  flatten uniform texture/sampler arrays to\n"
            "                                    scalars\n"
+           "  --glsl-version {100 | 110 | 120 | 130 | 140 | 150 |\n"
+           "                300es | 310es | 320es | 330\n"
+           "                400 | 410 | 420 | 430 | 440 | 450 | 460}\n"
+           "                                    set GLSL version, overrides #version\n"
+           "                                    in shader sourcen\n"
            "  --hlsl-offsets                    allow block offsets to follow HLSL rules\n"
            "                                    works independently of source language\n"
            "  --hlsl-iomap                      perform IO mapping in HLSL register space\n"
@@ -1847,7 +1970,10 @@
            "  --hlsl-dx9-compatible             interprets sampler declarations as a\n"
            "                                    texture/sampler combo like DirectX9 would,\n"
            "                                    and recognizes DirectX9-specific semantics\n"
+           "  --hlsl-dx-position-w              W component of SV_Position in HLSL fragment\n"
+           "                                    shaders compatible with DirectX\n"
            "  --invert-y | --iy                 invert position.Y output in vertex shader\n"
+           "  --enhanced-msgs                   print more readable error messages (GLSL only)\n"
            "  --keep-uncalled | --ku            don't eliminate uncalled functions\n"
            "  --nan-clamp                       favor non-NaN operand in min, max, and clamp\n"
            "  --no-storage-format | --nsf       use Unknown image format\n"
@@ -1922,8 +2048,9 @@
            "  --sep                             synonym for --source-entrypoint\n"
            "  --stdin                           read from stdin instead of from a file;\n"
            "                                    requires providing the shader stage using -S\n"
-           "  --target-env {vulkan1.0 | vulkan1.1 | vulkan1.2 | opengl | \n"
-           "                spirv1.0 | spirv1.1 | spirv1.2 | spirv1.3 | spirv1.4 | spirv1.5}\n"
+           "  --target-env {vulkan1.0 | vulkan1.1 | vulkan1.2 | vulkan1.3 | opengl |\n"
+           "                spirv1.0 | spirv1.1 | spirv1.2 | spirv1.3 | spirv1.4 |\n"
+           "                spirv1.5 | spirv1.6}\n"
            "                                    Set the execution environment that the\n"
            "                                    generated code will be executed in.\n"
            "                                    Defaults to:\n"
@@ -1932,6 +2059,7 @@
            "                                     * spirv1.0  under --target-env vulkan1.0\n"
            "                                     * spirv1.3  under --target-env vulkan1.1\n"
            "                                     * spirv1.5  under --target-env vulkan1.2\n"
+           "                                     * spirv1.6  under --target-env vulkan1.3\n"
            "                                    Multiple --target-env can be specified.\n"
            "  --variable-name <name>\n"
            "  --vn <name>                       creates a C header file that contains a\n"
diff --git a/StandAlone/spirv-remap.cpp b/StandAlone/spirv-remap.cpp
index 48878c3..15c3ac5 100644
--- a/StandAlone/spirv-remap.cpp
+++ b/StandAlone/spirv-remap.cpp
@@ -105,6 +105,32 @@
         }
     }
 
+    // Read strings from a file
+    void read(std::vector<std::string>& strings, const std::string& inFilename, int verbosity)
+    {
+        std::ifstream fp;
+
+        if (verbosity > 0)
+            logHandler(std::string("  reading: ") + inFilename);
+
+        strings.clear();
+        fp.open(inFilename, std::fstream::in);
+
+        if (fp.fail())
+            errHandler("error opening file for read: ");
+
+        std::string line;
+        while (std::getline(fp, line))
+        {
+            // Ignore empty lines and lines starting with the comment marker '#'.
+            if (line.length() == 0 || line[0] == '#') {
+                continue;
+            }
+
+            strings.push_back(line);
+        }
+    }
+
     void write(std::vector<SpvWord>& spv, const std::string& outFile, int verbosity)
     {
         if (outFile.empty())
@@ -144,6 +170,7 @@
             << " [--dce (all|types|funcs)]"
             << " [--opt (all|loadstore)]"
             << " [--strip-all | --strip all | -s]"
+            << " [--strip-white-list]"
             << " [--do-everything]"
             << " --input | -i file1 [file2...] --output|-o DESTDIR"
             << std::endl;
@@ -156,16 +183,18 @@
 
     // grind through each SPIR in turn
     void execute(const std::vector<std::string>& inputFile, const std::string& outputDir,
-        int opts, int verbosity)
+                 const std::string& whiteListFile, int opts, int verbosity)
     {
+        std::vector<std::string> whiteListStrings;
+        if(!whiteListFile.empty())
+            read(whiteListStrings, whiteListFile, verbosity);
+
         for (auto it = inputFile.cbegin(); it != inputFile.cend(); ++it) {
             const std::string &filename = *it;
             std::vector<SpvWord> spv;
             read(spv, filename, verbosity);
-            spv::spirvbin_t(verbosity).remap(spv, opts);
-
+            spv::spirvbin_t(verbosity).remap(spv, whiteListStrings, opts);
             const std::string outfile = outputDir + path_sep_char() + basename(filename);
-
             write(spv, outfile, verbosity);
         }
 
@@ -176,6 +205,7 @@
     // Parse command line options
     void parseCmdLine(int argc, char** argv, std::vector<std::string>& inputFile,
         std::string& outputDir,
+        std::string& stripWhiteListFile,
         int& options,
         int& verbosity)
     {
@@ -245,6 +275,9 @@
                     options = options | spv::spirvbin_t::STRIP;
                     ++a;
                 }
+            } else if (arg == "--strip-white-list") {
+                ++a;
+                stripWhiteListFile = argv[a++];
             } else if (arg == "--dce") {
                 // Parse comma (or colon, etc) separated list of things to dce
                 ++a;
@@ -315,6 +348,7 @@
 {
     std::vector<std::string> inputFile;
     std::string              outputDir;
+    std::string              whiteListFile;
     int                      opts;
     int                      verbosity;
 
@@ -329,13 +363,13 @@
     if (argc < 2)
         usage(argv[0]);
 
-    parseCmdLine(argc, argv, inputFile, outputDir, opts, verbosity);
+    parseCmdLine(argc, argv, inputFile, outputDir, whiteListFile, opts, verbosity);
 
     if (outputDir.empty())
         usage(argv[0], "Output directory required");
 
     // Main operations: read, remap, and write.
-    execute(inputFile, outputDir, opts, verbosity);
+    execute(inputFile, outputDir, whiteListFile, opts, verbosity);
 
     // If we get here, everything went OK!  Nothing more to be done.
 }
diff --git a/Test/150.frag b/Test/150.frag
index 228e4f0..90b1e27 100644
--- a/Test/150.frag
+++ b/Test/150.frag
@@ -111,8 +111,8 @@
     vec2 pf2;

     vec3 pf3;

 

-    lod = textureQueryLod(samp1D, pf);      // ERROR, extension GL_ARB_texture_query_lod needed

-    lod = textureQueryLod(samp2Ds, pf2);    // ERROR, extension GL_ARB_texture_query_lod needed

+    lod = textureQueryLOD(samp1D, pf);      // ERROR, extension GL_ARB_texture_query_lod needed

+    lod = textureQueryLOD(samp2Ds, pf2);    // ERROR, extension GL_ARB_texture_query_lod needed

 }

 

 #extension GL_ARB_texture_query_lod : enable

@@ -138,21 +138,21 @@
     vec2 pf2;

     vec3 pf3;

 

-    lod = textureQueryLod(samp1D, pf);

-    lod = textureQueryLod(isamp2D, pf2);

-    lod = textureQueryLod(usamp3D, pf3);

-    lod = textureQueryLod(sampCube, pf3);

-    lod = textureQueryLod(isamp1DA, pf);

-    lod = textureQueryLod(usamp2DA, pf2);

+    lod = textureQueryLOD(samp1D, pf);

+    lod = textureQueryLOD(isamp2D, pf2);

+    lod = textureQueryLOD(usamp3D, pf3);

+    lod = textureQueryLOD(sampCube, pf3);

+    lod = textureQueryLOD(isamp1DA, pf);

+    lod = textureQueryLOD(usamp2DA, pf2);

 

-    lod = textureQueryLod(samp1Ds, pf);

-    lod = textureQueryLod(samp2Ds, pf2);

-    lod = textureQueryLod(sampCubes, pf3);

-    lod = textureQueryLod(samp1DAs, pf);

-    lod = textureQueryLod(samp2DAs, pf2);

+    lod = textureQueryLOD(samp1Ds, pf);

+    lod = textureQueryLOD(samp2Ds, pf2);

+    lod = textureQueryLOD(sampCubes, pf3);

+    lod = textureQueryLOD(samp1DAs, pf);

+    lod = textureQueryLOD(samp2DAs, pf2);

 

-    lod = textureQueryLod(sampBuf, pf);     // ERROR

-    lod = textureQueryLod(sampRect, pf2);   // ERROR

+    lod = textureQueryLOD(sampBuf, pf);     // ERROR

+    lod = textureQueryLOD(sampRect, pf2);   // ERROR

 }

 

 // Test extension GL_EXT_shader_integer_mix

diff --git a/Test/BestMatchFunction.vert b/Test/BestMatchFunction.vert
new file mode 100644
index 0000000..eb09233
--- /dev/null
+++ b/Test/BestMatchFunction.vert
@@ -0,0 +1,20 @@
+#version 150
+#extension GL_ARB_gpu_shader5 : require
+
+uniform ivec4 u1;
+uniform uvec4 u2;
+out     vec4  result;
+vec4 f(in vec4 a, in vec4 b){ return a * b;}           // choice 1
+vec4 f(in uvec4 a, in uvec4 b){ return vec4(a - b);}   // choice 2
+
+void main()
+{
+    result = f(u1, u2); // should match choice 2. which have less implicit conversion. 
+    switch (gl_VertexID)
+    {
+      case 0: gl_Position = vec4(-1.0, 1.0, 0.0, 1.0); break;
+      case 1: gl_Position = vec4( 1.0, 1.0, 0.0, 1.0); break;
+      case 2: gl_Position = vec4(-1.0,-1.0, 0.0, 1.0); break;
+      case 3: gl_Position = vec4( 1.0,-1.0, 0.0, 1.0); break;
+    }
+}
diff --git a/Test/EndStreamPrimitive.geom b/Test/EndStreamPrimitive.geom
new file mode 100644
index 0000000..a654ebc
--- /dev/null
+++ b/Test/EndStreamPrimitive.geom
@@ -0,0 +1,20 @@
+#version 150 core
+#extension GL_ARB_gpu_shader5 : require
+layout(points) in;
+layout(points, max_vertices = 1) out;
+layout(stream=0) out float output1;
+layout(stream=0) out float output2;
+layout(stream=1) out float output3;
+layout(stream=1) out float output4;
+uniform uint stream;
+void main() {
+
+    output1 = 1.0;
+    output2 = 2.0;
+    EmitStreamVertex(0);
+    EndStreamPrimitive(0);
+    output3 = 3.0;
+    output4 = 4.0;
+    EmitStreamVertex(1);
+    EndStreamPrimitive(1);
+}
\ No newline at end of file
diff --git a/Test/GL_ARB_fragment_coord_conventions.vert b/Test/GL_ARB_fragment_coord_conventions.vert
new file mode 100644
index 0000000..962734f
--- /dev/null
+++ b/Test/GL_ARB_fragment_coord_conventions.vert
@@ -0,0 +1,27 @@
+#version 140
+
+#extension GL_ARB_fragment_coord_conventions: require
+#extension GL_ARB_explicit_attrib_location : enable
+
+
+#if !defined GL_ARB_fragment_coord_conventions
+#  error GL_ARB_fragment_coord_conventions is not defined
+#elif GL_ARB_fragment_coord_conventions != 1
+#  error GL_ARB_fragment_coord_conventions is not equal to 1
+#endif
+
+
+layout (location = 0) in vec4 pos;
+out vec4 i;
+
+uniform float gtf_windowWidth;
+uniform float gtf_windowHeight;
+uniform float n;
+uniform float f;
+
+void main()
+{
+  gl_Position = pos;
+  i = vec4((pos.x+1.0)*0.5*gtf_windowWidth, (pos.y+1.0)*0.5*gtf_windowHeight, (f-n)*0.5*pos.z + (f+n)*0.5, pos.w);
+}
+
diff --git a/Test/baseLegalResults/hlsl.aliasOpaque.frag.out b/Test/baseLegalResults/hlsl.aliasOpaque.frag.out
index 2afdb10..100f6d7 100644
--- a/Test/baseLegalResults/hlsl.aliasOpaque.frag.out
+++ b/Test/baseLegalResults/hlsl.aliasOpaque.frag.out
@@ -1,6 +1,6 @@
 hlsl.aliasOpaque.frag
 // Module Version 10000
-// Generated by (magic number): 8000a
+// Generated by (magic number): 8000b
 // Id's are bound by 89
 
                               Capability Shader
diff --git a/Test/baseLegalResults/hlsl.flattenOpaque.frag.out b/Test/baseLegalResults/hlsl.flattenOpaque.frag.out
index 7bb33e6..be1637f 100644
--- a/Test/baseLegalResults/hlsl.flattenOpaque.frag.out
+++ b/Test/baseLegalResults/hlsl.flattenOpaque.frag.out
@@ -1,6 +1,6 @@
 hlsl.flattenOpaque.frag
 // Module Version 10000
-// Generated by (magic number): 8000a
+// Generated by (magic number): 8000b
 // Id's are bound by 190
 
                               Capability Shader
diff --git a/Test/baseLegalResults/hlsl.flattenOpaqueInit.vert.out b/Test/baseLegalResults/hlsl.flattenOpaqueInit.vert.out
index 0e8583f..18d7694 100644
--- a/Test/baseLegalResults/hlsl.flattenOpaqueInit.vert.out
+++ b/Test/baseLegalResults/hlsl.flattenOpaqueInit.vert.out
@@ -1,6 +1,6 @@
 hlsl.flattenOpaqueInit.vert
 // Module Version 10000
-// Generated by (magic number): 8000a
+// Generated by (magic number): 8000b
 // Id's are bound by 139
 
                               Capability Shader
diff --git a/Test/baseLegalResults/hlsl.flattenOpaqueInitMix.vert.out b/Test/baseLegalResults/hlsl.flattenOpaqueInitMix.vert.out
index fe858ef..914d9b5 100644
--- a/Test/baseLegalResults/hlsl.flattenOpaqueInitMix.vert.out
+++ b/Test/baseLegalResults/hlsl.flattenOpaqueInitMix.vert.out
@@ -1,6 +1,6 @@
 hlsl.flattenOpaqueInitMix.vert
 // Module Version 10000
-// Generated by (magic number): 8000a
+// Generated by (magic number): 8000b
 // Id's are bound by 99
 
                               Capability Shader
diff --git a/Test/baseLegalResults/hlsl.flattenSubset.frag.out b/Test/baseLegalResults/hlsl.flattenSubset.frag.out
index 0edf712..2be41f0 100644
--- a/Test/baseLegalResults/hlsl.flattenSubset.frag.out
+++ b/Test/baseLegalResults/hlsl.flattenSubset.frag.out
@@ -1,24 +1,22 @@
 hlsl.flattenSubset.frag
 // Module Version 10000
-// Generated by (magic number): 8000a
+// Generated by (magic number): 8000b
 // Id's are bound by 67
 
                               Capability Shader
                1:             ExtInstImport  "GLSL.std.450"
                               MemoryModel Logical GLSL450
-                              EntryPoint Fragment 4  "main" 47 50
+                              EntryPoint Fragment 4  "main" 50
                               ExecutionMode 4 OriginUpperLeft
                               Source HLSL 500
                               Name 4  "main"
                               Name 21  "samp"
                               Name 33  "tex"
-                              Name 47  "vpos"
                               Name 50  "@entryPointOutput"
                               Decorate 21(samp) DescriptorSet 0
                               Decorate 21(samp) Binding 0
                               Decorate 33(tex) DescriptorSet 0
                               Decorate 33(tex) Binding 1
-                              Decorate 47(vpos) Location 0
                               Decorate 50(@entryPointOutput) Location 0
                2:             TypeVoid
                3:             TypeFunction 2
@@ -34,8 +32,6 @@
               39:             TypeVector 6(float) 2
               40:    6(float) Constant 1056964608
               41:   39(fvec2) ConstantComposite 40 40
-              46:             TypePointer Input 7(fvec4)
-        47(vpos):     46(ptr) Variable Input
               49:             TypePointer Output 7(fvec4)
 50(@entryPointOutput):     49(ptr) Variable Output
          4(main):           2 Function None 3
diff --git a/Test/baseLegalResults/hlsl.flattenSubset2.frag.out b/Test/baseLegalResults/hlsl.flattenSubset2.frag.out
index 00bd55b..656ff73 100644
--- a/Test/baseLegalResults/hlsl.flattenSubset2.frag.out
+++ b/Test/baseLegalResults/hlsl.flattenSubset2.frag.out
@@ -1,18 +1,16 @@
 hlsl.flattenSubset2.frag
 // Module Version 10000
-// Generated by (magic number): 8000a
+// Generated by (magic number): 8000b
 // Id's are bound by 53
 
                               Capability Shader
                1:             ExtInstImport  "GLSL.std.450"
                               MemoryModel Logical GLSL450
-                              EntryPoint Fragment 4  "main" 49 52
+                              EntryPoint Fragment 4  "main" 52
                               ExecutionMode 4 OriginUpperLeft
                               Source HLSL 500
                               Name 4  "main"
-                              Name 49  "vpos"
                               Name 52  "@entryPointOutput"
-                              Decorate 49(vpos) Location 0
                               Decorate 52(@entryPointOutput) Location 0
                2:             TypeVoid
                3:             TypeFunction 2
@@ -20,8 +18,6 @@
                7:             TypeVector 6(float) 4
               43:    6(float) Constant 0
               44:    7(fvec4) ConstantComposite 43 43 43 43
-              48:             TypePointer Input 7(fvec4)
-        49(vpos):     48(ptr) Variable Input
               51:             TypePointer Output 7(fvec4)
 52(@entryPointOutput):     51(ptr) Variable Output
          4(main):           2 Function None 3
diff --git a/Test/baseLegalResults/hlsl.intrinsics.evalfns.frag.out b/Test/baseLegalResults/hlsl.intrinsics.evalfns.frag.out
index 564f0f4..936df71 100644
--- a/Test/baseLegalResults/hlsl.intrinsics.evalfns.frag.out
+++ b/Test/baseLegalResults/hlsl.intrinsics.evalfns.frag.out
@@ -1,6 +1,6 @@
 hlsl.intrinsics.evalfns.frag
 // Module Version 10000
-// Generated by (magic number): 8000a
+// Generated by (magic number): 8000b
 // Id's are bound by 274
 
                               Capability Shader
diff --git a/Test/baseLegalResults/hlsl.partialFlattenLocal.vert.out b/Test/baseLegalResults/hlsl.partialFlattenLocal.vert.out
index f45a768..b664098 100644
--- a/Test/baseLegalResults/hlsl.partialFlattenLocal.vert.out
+++ b/Test/baseLegalResults/hlsl.partialFlattenLocal.vert.out
@@ -1,6 +1,6 @@
 hlsl.partialFlattenLocal.vert
 // Module Version 10000
-// Generated by (magic number): 8000a
+// Generated by (magic number): 8000b
 // Id's are bound by 164
 
                               Capability Shader
diff --git a/Test/baseLegalResults/hlsl.partialFlattenMixed.vert.out b/Test/baseLegalResults/hlsl.partialFlattenMixed.vert.out
index 8975ed2..8f3ac26 100644
--- a/Test/baseLegalResults/hlsl.partialFlattenMixed.vert.out
+++ b/Test/baseLegalResults/hlsl.partialFlattenMixed.vert.out
@@ -1,6 +1,6 @@
 hlsl.partialFlattenMixed.vert
 // Module Version 10000
-// Generated by (magic number): 8000a
+// Generated by (magic number): 8000b
 // Id's are bound by 36
 
                               Capability Shader
diff --git a/Test/baseResults/150.frag.out b/Test/baseResults/150.frag.out
index 2192e14..ba15b5c 100644
--- a/Test/baseResults/150.frag.out
+++ b/Test/baseResults/150.frag.out
@@ -2,22 +2,23 @@
 ERROR: 0:4: 'redeclaration' : cannot redeclare with different qualification: gl_FragCoord
 ERROR: 0:5: 'redeclaration' : cannot redeclare with different qualification: gl_FragCoord
 ERROR: 0:6: 'layout qualifier' : can only apply origin_upper_left and pixel_center_origin to gl_FragCoord 
-ERROR: 0:14: 'gl_FragCoord' : cannot redeclare after use 
 ERROR: 0:50: 'gl_PerFragment' : undeclared identifier 
 ERROR: 0:53: 'double' : Reserved word. 
 ERROR: 0:53: 'double' : not supported for this version or the enabled extensions 
 ERROR: 0:53: 'double' : must be qualified as flat in
 ERROR: 0:57: '=' :  cannot convert from ' global double' to ' global int'
-ERROR: 0:80: 'floatBitsToInt' : required extension not requested: GL_ARB_shader_bit_encoding
+ERROR: 0:80: 'floatBitsToInt' : required extension not requested: Possible extensions include:
+GL_ARB_shader_bit_encoding
+GL_ARB_gpu_shader5
 ERROR: 0:100: 'packSnorm2x16' : required extension not requested: GL_ARB_shading_language_packing
-ERROR: 0:114: 'textureQueryLod' : required extension not requested: GL_ARB_texture_query_lod
-ERROR: 0:115: 'textureQueryLod' : required extension not requested: GL_ARB_texture_query_lod
-ERROR: 0:154: 'textureQueryLod' : no matching overloaded function found 
+ERROR: 0:114: 'textureQueryLOD' : required extension not requested: GL_ARB_texture_query_lod
+ERROR: 0:115: 'textureQueryLOD' : required extension not requested: GL_ARB_texture_query_lod
+ERROR: 0:154: 'textureQueryLOD' : no matching overloaded function found 
 ERROR: 0:154: 'assign' :  cannot convert from ' const float' to ' temp 2-component vector of float'
-ERROR: 0:155: 'textureQueryLod' : no matching overloaded function found 
+ERROR: 0:155: 'textureQueryLOD' : no matching overloaded function found 
 ERROR: 0:155: 'assign' :  cannot convert from ' const float' to ' temp 2-component vector of float'
 ERROR: 0:183: 'mix' : required extension not requested: GL_EXT_shader_integer_mix
-ERROR: 18 compilation errors.  No code generated.
+ERROR: 17 compilation errors.  No code generated.
 
 
 Shader version: 150
diff --git a/Test/baseResults/150.geom.out b/Test/baseResults/150.geom.out
index 92b8e1a..c5a31f5 100644
--- a/Test/baseResults/150.geom.out
+++ b/Test/baseResults/150.geom.out
@@ -2,8 +2,8 @@
 ERROR: 0:15: 'fromVertex' : block instance name redefinition 
 ERROR: 0:19: 'fromVertex' : redefinition 
 ERROR: 0:21: 'fooC' : block instance name redefinition 
-ERROR: 0:29: 'EmitStreamVertex' : no matching overloaded function found 
-ERROR: 0:30: 'EndStreamPrimitive' : no matching overloaded function found 
+ERROR: 0:29: 'if the verison is 150 , the EmitStreamVertex and EndStreamPrimitive only support at extension GL_ARB_gpu_shader5' : required extension not requested: GL_ARB_gpu_shader5
+ERROR: 0:30: 'if the verison is 150 , the EmitStreamVertex and EndStreamPrimitive only support at extension GL_ARB_gpu_shader5' : required extension not requested: GL_ARB_gpu_shader5
 ERROR: 0:44: 'stream' : can only be used on an output 
 ERROR: 0:45: 'stream' : can only be used on an output 
 ERROR: 0:46: 'stream' : can only be used on an output 
@@ -49,10 +49,12 @@
 0:27    Sequence
 0:27      EmitVertex ( global void)
 0:28      EndPrimitive ( global void)
-0:29      Constant:
-0:29        0.000000
-0:30      Constant:
-0:30        0.000000
+0:29      EmitStreamVertex ( global void)
+0:29        Constant:
+0:29          1 (const int)
+0:30      EndStreamPrimitive ( global void)
+0:30        Constant:
+0:30          0 (const int)
 0:32      move second child to first child ( temp 3-component vector of float)
 0:32        color: direct index for structure (layout( stream=0) out 3-component vector of float)
 0:32          'anon@0' (layout( stream=0) out block{layout( stream=0) out 3-component vector of float color})
@@ -190,10 +192,12 @@
 0:27    Sequence
 0:27      EmitVertex ( global void)
 0:28      EndPrimitive ( global void)
-0:29      Constant:
-0:29        0.000000
-0:30      Constant:
-0:30        0.000000
+0:29      EmitStreamVertex ( global void)
+0:29        Constant:
+0:29          1 (const int)
+0:30      EndStreamPrimitive ( global void)
+0:30        Constant:
+0:30          0 (const int)
 0:32      move second child to first child ( temp 3-component vector of float)
 0:32        color: direct index for structure (layout( stream=0) out 3-component vector of float)
 0:32          'anon@0' (layout( stream=0) out block{layout( stream=0) out 3-component vector of float color})
diff --git a/Test/baseResults/150.tesc.out b/Test/baseResults/150.tesc.out
index 535a8a6..78b32da 100644
--- a/Test/baseResults/150.tesc.out
+++ b/Test/baseResults/150.tesc.out
@@ -627,7 +627,7 @@
 ERROR: 0:7: 'vertices' : inconsistent output number of vertices for array size of gl_out
 ERROR: 0:11: 'vertices' : inconsistent output number of vertices for array size of a
 ERROR: 0:12: 'vertices' : inconsistent output number of vertices for array size of outb
-ERROR: 0:26: 'gl_PointSize' : no such field in structure 
+ERROR: 0:26: 'gl_PointSize' : no such field in structure 'gl_out'
 ERROR: 0:26: 'assign' :  cannot convert from ' temp float' to ' temp block{ out 4-component vector of float Position gl_Position}'
 ERROR: 0:29: 'out' : type must be an array: outf
 ERROR: 0:43: 'vertices' : must be greater than 0 
@@ -940,8 +940,9 @@
     main(
 ERROR: Linking tessellation control stage: Multiple function bodies in multiple compilation units for the same signature in the same stage:
     main(
-ERROR: Linking tessellation control stage: Types must match:
-    outa: " global 4-element array of int" versus " global 1-element array of int"
+ERROR: Linking tessellation control and tessellation control stages: Array sizes must be compatible:
+    tessellation control stage: " int outa[4]"
+    tessellation control stage: " int outa[1]"
 ERROR: Linking tessellation control stage: can't handle multiple entry points per stage
 ERROR: Linking tessellation control stage: Multiple function bodies in multiple compilation units for the same signature in the same stage:
     main(
@@ -951,8 +952,9 @@
     foo(
 ERROR: Linking tessellation control stage: Multiple function bodies in multiple compilation units for the same signature in the same stage:
     main(
-ERROR: Linking tessellation control stage: Types must match:
-    gl_out: " out 4-element array of block{ out 4-component vector of float Position gl_Position,  out float PointSize gl_PointSize,  out unsized 2-element array of float ClipDistance gl_ClipDistance}" versus " out 3-element array of block{ out 4-component vector of float Position gl_Position}"
+ERROR: Linking tessellation control and tessellation control stages: tessellation control block member has no corresponding member in tessellation control block:
+    tessellation control stage: Block: gl_PerVertex, Member: gl_PointSize
+    tessellation control stage: Block: gl_PerVertex, Member: n/a 
 
 Linked tessellation evaluation stage:
 
diff --git a/Test/baseResults/310.geom.out b/Test/baseResults/310.geom.out
index b0dabc3..2fa5d11 100644
--- a/Test/baseResults/310.geom.out
+++ b/Test/baseResults/310.geom.out
@@ -6,7 +6,7 @@
 ERROR: 0:44: 'EndStreamPrimitive' : no matching overloaded function found 
 ERROR: 0:47: 'gl_ClipDistance' : undeclared identifier 
 ERROR: 0:47: 'gl_ClipDistance' :  left of '[' is not of type array, matrix, or vector  
-ERROR: 0:48: 'gl_ClipDistance' : no such field in structure 
+ERROR: 0:48: 'gl_ClipDistance' : no such field in structure 'gl_in'
 ERROR: 0:48: 'expression' :  left of '[' is not of type array, matrix, or vector  
 ERROR: 0:47: 'assign' :  l-value required (can't modify a const)
 ERROR: 0:55: 'selecting output stream' : not supported with this profile: es
diff --git a/Test/baseResults/310.tesc.out b/Test/baseResults/310.tesc.out
index 25ce6ee..bd4c1bd 100644
--- a/Test/baseResults/310.tesc.out
+++ b/Test/baseResults/310.tesc.out
@@ -6,12 +6,12 @@
 ERROR: 0:26: 'gl_PointSize' : required extension not requested: Possible extensions include:
 GL_EXT_tessellation_point_size
 GL_OES_tessellation_point_size
-ERROR: 0:27: 'gl_ClipDistance' : no such field in structure 
+ERROR: 0:27: 'gl_ClipDistance' : no such field in structure 'gl_in'
 ERROR: 0:27: 'expression' :  left of '[' is not of type array, matrix, or vector  
 ERROR: 0:34: 'gl_PointSize' : required extension not requested: Possible extensions include:
 GL_EXT_tessellation_point_size
 GL_OES_tessellation_point_size
-ERROR: 0:35: 'gl_ClipDistance' : no such field in structure 
+ERROR: 0:35: 'gl_ClipDistance' : no such field in structure 'gl_out'
 ERROR: 0:35: 'expression' :  left of '[' is not of type array, matrix, or vector  
 ERROR: 0:35: 'assign' :  l-value required (can't modify a const)
 ERROR: 0:41: '' : tessellation control barrier() cannot be placed within flow control 
diff --git a/Test/baseResults/310.tese.out b/Test/baseResults/310.tese.out
index 2f23d9b..5eecaff 100644
--- a/Test/baseResults/310.tese.out
+++ b/Test/baseResults/310.tese.out
@@ -10,7 +10,7 @@
 ERROR: 0:37: 'gl_PointSize' : required extension not requested: Possible extensions include:
 GL_EXT_tessellation_point_size
 GL_OES_tessellation_point_size
-ERROR: 0:38: 'gl_ClipDistance' : no such field in structure 
+ERROR: 0:38: 'gl_ClipDistance' : no such field in structure 'gl_in'
 ERROR: 0:38: 'expression' :  left of '[' is not of type array, matrix, or vector  
 ERROR: 0:47: 'gl_PointSize' : required extension not requested: Possible extensions include:
 GL_EXT_tessellation_point_size
@@ -43,7 +43,7 @@
 ERROR: 0:103: 'location' : overlapping use of location 24
 ERROR: 0:105: 'gl_TessLevelOuter' : identifiers starting with "gl_" are reserved 
 ERROR: 0:113: 'sample' : Reserved word. 
-ERROR: 0:119: 'gl_PointSize' : no such field in structure 
+ERROR: 0:119: 'gl_PointSize' : no such field in structure 'gl_in'
 ERROR: 0:119: '=' :  cannot convert from ' temp block{ in highp 4-component vector of float Position gl_Position}' to ' temp highp float'
 ERROR: 0:127: 'gl_BoundingBoxOES' : undeclared identifier 
 ERROR: 43 compilation errors.  No code generated.
diff --git a/Test/baseResults/320.geom.out b/Test/baseResults/320.geom.out
index f333766..cdaacb9 100644
--- a/Test/baseResults/320.geom.out
+++ b/Test/baseResults/320.geom.out
@@ -6,7 +6,7 @@
 ERROR: 0:34: 'EndStreamPrimitive' : no matching overloaded function found 
 ERROR: 0:37: 'gl_ClipDistance' : undeclared identifier 
 ERROR: 0:37: 'gl_ClipDistance' :  left of '[' is not of type array, matrix, or vector  
-ERROR: 0:38: 'gl_ClipDistance' : no such field in structure 
+ERROR: 0:38: 'gl_ClipDistance' : no such field in structure 'gl_in'
 ERROR: 0:38: 'expression' :  left of '[' is not of type array, matrix, or vector  
 ERROR: 0:37: 'assign' :  l-value required (can't modify a const)
 ERROR: 0:45: 'selecting output stream' : not supported with this profile: es
diff --git a/Test/baseResults/320.tesc.out b/Test/baseResults/320.tesc.out
index 6bb52b3..67848d9 100644
--- a/Test/baseResults/320.tesc.out
+++ b/Test/baseResults/320.tesc.out
@@ -6,12 +6,12 @@
 ERROR: 0:24: 'gl_PointSize' : required extension not requested: Possible extensions include:
 GL_EXT_tessellation_point_size
 GL_OES_tessellation_point_size
-ERROR: 0:25: 'gl_ClipDistance' : no such field in structure 
+ERROR: 0:25: 'gl_ClipDistance' : no such field in structure 'gl_in'
 ERROR: 0:25: 'expression' :  left of '[' is not of type array, matrix, or vector  
 ERROR: 0:32: 'gl_PointSize' : required extension not requested: Possible extensions include:
 GL_EXT_tessellation_point_size
 GL_OES_tessellation_point_size
-ERROR: 0:33: 'gl_ClipDistance' : no such field in structure 
+ERROR: 0:33: 'gl_ClipDistance' : no such field in structure 'gl_out'
 ERROR: 0:33: 'expression' :  left of '[' is not of type array, matrix, or vector  
 ERROR: 0:33: 'assign' :  l-value required (can't modify a const)
 ERROR: 0:39: '' : tessellation control barrier() cannot be placed within flow control 
diff --git a/Test/baseResults/320.tese.out b/Test/baseResults/320.tese.out
index 014eeb0..ba51b9c 100644
--- a/Test/baseResults/320.tese.out
+++ b/Test/baseResults/320.tese.out
@@ -10,7 +10,7 @@
 ERROR: 0:33: 'gl_PointSize' : required extension not requested: Possible extensions include:
 GL_EXT_tessellation_point_size
 GL_OES_tessellation_point_size
-ERROR: 0:34: 'gl_ClipDistance' : no such field in structure 
+ERROR: 0:34: 'gl_ClipDistance' : no such field in structure 'gl_in'
 ERROR: 0:34: 'expression' :  left of '[' is not of type array, matrix, or vector  
 ERROR: 0:43: 'gl_PointSize' : required extension not requested: Possible extensions include:
 GL_EXT_tessellation_point_size
diff --git a/Test/baseResults/410.geom.out b/Test/baseResults/410.geom.out
index 498da5a..3cc7900 100644
--- a/Test/baseResults/410.geom.out
+++ b/Test/baseResults/410.geom.out
@@ -2,7 +2,7 @@
 ERROR: 0:8: 'myIn' : cannot redeclare a built-in block with a user name 
 ERROR: 0:12: 'gl_myIn' : no declaration found for redeclaration 
 ERROR: 0:20: 'gl_PerVertex' : can only redeclare a built-in block once, and before any use 
-ERROR: 0:32: 'gl_Position' : no such field in structure 
+ERROR: 0:32: 'gl_Position' : no such field in structure 'gl_in'
 ERROR: 0:32: '=' :  cannot convert from ' temp block{ in float PointSize gl_PointSize}' to ' temp 4-component vector of float'
 ERROR: 0:33: 'gl_Position' : member of nameless block was not redeclared 
 ERROR: 0:33: 'assign' :  l-value required "gl_PerVertex" (can't modify void)
diff --git a/Test/baseResults/420.tesc.out b/Test/baseResults/420.tesc.out
index a1f881c..4410c84 100644
--- a/Test/baseResults/420.tesc.out
+++ b/Test/baseResults/420.tesc.out
@@ -2,7 +2,7 @@
 ERROR: 0:7: 'vertices' : inconsistent output number of vertices for array size of gl_out
 ERROR: 0:11: 'vertices' : inconsistent output number of vertices for array size of a
 ERROR: 0:12: 'vertices' : inconsistent output number of vertices for array size of outb
-ERROR: 0:26: 'gl_PointSize' : no such field in structure 
+ERROR: 0:26: 'gl_PointSize' : no such field in structure 'gl_out'
 ERROR: 0:26: 'assign' :  cannot convert from ' temp float' to ' temp block{ out 4-component vector of float Position gl_Position}'
 ERROR: 0:29: 'out' : type must be an array: outf
 ERROR: 0:43: 'vertices' : must be greater than 0 
diff --git a/Test/baseResults/450.geom.out b/Test/baseResults/450.geom.out
index e75bf93..b51a674 100644
--- a/Test/baseResults/450.geom.out
+++ b/Test/baseResults/450.geom.out
@@ -1,6 +1,6 @@
 450.geom
 ERROR: 0:15: '[' :  array index out of range '3'
-ERROR: 0:15: 'gl_Position' : no such field in structure 
+ERROR: 0:15: 'gl_Position' : no such field in structure 'gl_in'
 ERROR: 0:19: 'points' : can only apply to a standalone qualifier 
 ERROR: 3 compilation errors.  No code generated.
 
diff --git a/Test/baseResults/BestMatchFunction.vert.out b/Test/baseResults/BestMatchFunction.vert.out
new file mode 100644
index 0000000..843ffd7
--- /dev/null
+++ b/Test/baseResults/BestMatchFunction.vert.out
@@ -0,0 +1,206 @@
+BestMatchFunction.vert
+WARNING: 0:2: '#extension' : extension is only partially supported: GL_ARB_gpu_shader5
+
+Shader version: 150
+Requested GL_ARB_gpu_shader5
+0:? Sequence
+0:7  Function Definition: f(vf4;vf4; ( global 4-component vector of float)
+0:7    Function Parameters: 
+0:7      'a' ( in 4-component vector of float)
+0:7      'b' ( in 4-component vector of float)
+0:7    Sequence
+0:7      Branch: Return with expression
+0:7        component-wise multiply ( temp 4-component vector of float)
+0:7          'a' ( in 4-component vector of float)
+0:7          'b' ( in 4-component vector of float)
+0:8  Function Definition: f(vu4;vu4; ( global 4-component vector of float)
+0:8    Function Parameters: 
+0:8      'a' ( in 4-component vector of uint)
+0:8      'b' ( in 4-component vector of uint)
+0:8    Sequence
+0:8      Branch: Return with expression
+0:8        Convert uint to float ( temp 4-component vector of float)
+0:8          subtract ( temp 4-component vector of uint)
+0:8            'a' ( in 4-component vector of uint)
+0:8            'b' ( in 4-component vector of uint)
+0:10  Function Definition: main( ( global void)
+0:10    Function Parameters: 
+0:12    Sequence
+0:12      move second child to first child ( temp 4-component vector of float)
+0:12        'result' ( smooth out 4-component vector of float)
+0:12        Function Call: f(vu4;vu4; ( global 4-component vector of float)
+0:12          Convert int to uint ( temp 4-component vector of uint)
+0:12            'u1' ( uniform 4-component vector of int)
+0:12          'u2' ( uniform 4-component vector of uint)
+0:13      switch
+0:13      condition
+0:13        'gl_VertexID' ( gl_VertexId int VertexId)
+0:13      body
+0:13        Sequence
+0:15          case:  with expression
+0:15            Constant:
+0:15              0 (const int)
+0:?           Sequence
+0:15            move second child to first child ( temp 4-component vector of float)
+0:15              gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:15                'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position,  gl_PointSize float PointSize gl_PointSize,  out unsized 1-element array of float ClipDistance gl_ClipDistance})
+0:15                Constant:
+0:15                  0 (const uint)
+0:15              Constant:
+0:15                -1.000000
+0:15                1.000000
+0:15                0.000000
+0:15                1.000000
+0:15            Branch: Break
+0:16          case:  with expression
+0:16            Constant:
+0:16              1 (const int)
+0:?           Sequence
+0:16            move second child to first child ( temp 4-component vector of float)
+0:16              gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:16                'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position,  gl_PointSize float PointSize gl_PointSize,  out unsized 1-element array of float ClipDistance gl_ClipDistance})
+0:16                Constant:
+0:16                  0 (const uint)
+0:16              Constant:
+0:16                1.000000
+0:16                1.000000
+0:16                0.000000
+0:16                1.000000
+0:16            Branch: Break
+0:17          case:  with expression
+0:17            Constant:
+0:17              2 (const int)
+0:?           Sequence
+0:17            move second child to first child ( temp 4-component vector of float)
+0:17              gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:17                'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position,  gl_PointSize float PointSize gl_PointSize,  out unsized 1-element array of float ClipDistance gl_ClipDistance})
+0:17                Constant:
+0:17                  0 (const uint)
+0:17              Constant:
+0:17                -1.000000
+0:17                -1.000000
+0:17                0.000000
+0:17                1.000000
+0:17            Branch: Break
+0:18          case:  with expression
+0:18            Constant:
+0:18              3 (const int)
+0:?           Sequence
+0:18            move second child to first child ( temp 4-component vector of float)
+0:18              gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:18                'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position,  gl_PointSize float PointSize gl_PointSize,  out unsized 1-element array of float ClipDistance gl_ClipDistance})
+0:18                Constant:
+0:18                  0 (const uint)
+0:18              Constant:
+0:18                1.000000
+0:18                -1.000000
+0:18                0.000000
+0:18                1.000000
+0:18            Branch: Break
+0:?   Linker Objects
+0:?     'u1' ( uniform 4-component vector of int)
+0:?     'u2' ( uniform 4-component vector of uint)
+0:?     'result' ( smooth out 4-component vector of float)
+0:?     'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position,  gl_PointSize float PointSize gl_PointSize,  out unsized 1-element array of float ClipDistance gl_ClipDistance})
+0:?     'gl_VertexID' ( gl_VertexId int VertexId)
+0:?     'gl_InstanceID' ( gl_InstanceId int InstanceId)
+
+
+Linked vertex stage:
+
+
+Shader version: 150
+Requested GL_ARB_gpu_shader5
+0:? Sequence
+0:8  Function Definition: f(vu4;vu4; ( global 4-component vector of float)
+0:8    Function Parameters: 
+0:8      'a' ( in 4-component vector of uint)
+0:8      'b' ( in 4-component vector of uint)
+0:8    Sequence
+0:8      Branch: Return with expression
+0:8        Convert uint to float ( temp 4-component vector of float)
+0:8          subtract ( temp 4-component vector of uint)
+0:8            'a' ( in 4-component vector of uint)
+0:8            'b' ( in 4-component vector of uint)
+0:10  Function Definition: main( ( global void)
+0:10    Function Parameters: 
+0:12    Sequence
+0:12      move second child to first child ( temp 4-component vector of float)
+0:12        'result' ( smooth out 4-component vector of float)
+0:12        Function Call: f(vu4;vu4; ( global 4-component vector of float)
+0:12          Convert int to uint ( temp 4-component vector of uint)
+0:12            'u1' ( uniform 4-component vector of int)
+0:12          'u2' ( uniform 4-component vector of uint)
+0:13      switch
+0:13      condition
+0:13        'gl_VertexID' ( gl_VertexId int VertexId)
+0:13      body
+0:13        Sequence
+0:15          case:  with expression
+0:15            Constant:
+0:15              0 (const int)
+0:?           Sequence
+0:15            move second child to first child ( temp 4-component vector of float)
+0:15              gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:15                'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position,  gl_PointSize float PointSize gl_PointSize,  out 1-element array of float ClipDistance gl_ClipDistance})
+0:15                Constant:
+0:15                  0 (const uint)
+0:15              Constant:
+0:15                -1.000000
+0:15                1.000000
+0:15                0.000000
+0:15                1.000000
+0:15            Branch: Break
+0:16          case:  with expression
+0:16            Constant:
+0:16              1 (const int)
+0:?           Sequence
+0:16            move second child to first child ( temp 4-component vector of float)
+0:16              gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:16                'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position,  gl_PointSize float PointSize gl_PointSize,  out 1-element array of float ClipDistance gl_ClipDistance})
+0:16                Constant:
+0:16                  0 (const uint)
+0:16              Constant:
+0:16                1.000000
+0:16                1.000000
+0:16                0.000000
+0:16                1.000000
+0:16            Branch: Break
+0:17          case:  with expression
+0:17            Constant:
+0:17              2 (const int)
+0:?           Sequence
+0:17            move second child to first child ( temp 4-component vector of float)
+0:17              gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:17                'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position,  gl_PointSize float PointSize gl_PointSize,  out 1-element array of float ClipDistance gl_ClipDistance})
+0:17                Constant:
+0:17                  0 (const uint)
+0:17              Constant:
+0:17                -1.000000
+0:17                -1.000000
+0:17                0.000000
+0:17                1.000000
+0:17            Branch: Break
+0:18          case:  with expression
+0:18            Constant:
+0:18              3 (const int)
+0:?           Sequence
+0:18            move second child to first child ( temp 4-component vector of float)
+0:18              gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:18                'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position,  gl_PointSize float PointSize gl_PointSize,  out 1-element array of float ClipDistance gl_ClipDistance})
+0:18                Constant:
+0:18                  0 (const uint)
+0:18              Constant:
+0:18                1.000000
+0:18                -1.000000
+0:18                0.000000
+0:18                1.000000
+0:18            Branch: Break
+0:?   Linker Objects
+0:?     'u1' ( uniform 4-component vector of int)
+0:?     'u2' ( uniform 4-component vector of uint)
+0:?     'result' ( smooth out 4-component vector of float)
+0:?     'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position,  gl_PointSize float PointSize gl_PointSize,  out 1-element array of float ClipDistance gl_ClipDistance})
+0:?     'gl_VertexID' ( gl_VertexId int VertexId)
+0:?     'gl_InstanceID' ( gl_InstanceId int InstanceId)
+
diff --git a/Test/baseResults/EndStreamPrimitive.geom.out b/Test/baseResults/EndStreamPrimitive.geom.out
new file mode 100644
index 0000000..702c3f9
--- /dev/null
+++ b/Test/baseResults/EndStreamPrimitive.geom.out
@@ -0,0 +1,97 @@
+EndStreamPrimitive.geom
+WARNING: 0:2: '#extension' : extension is only partially supported: GL_ARB_gpu_shader5
+
+Shader version: 150
+Requested GL_ARB_gpu_shader5
+invocations = -1
+max_vertices = 1
+input primitive = points
+output primitive = points
+0:? Sequence
+0:10  Function Definition: main( ( global void)
+0:10    Function Parameters: 
+0:12    Sequence
+0:12      move second child to first child ( temp float)
+0:12        'output1' (layout( stream=0) out float)
+0:12        Constant:
+0:12          1.000000
+0:13      move second child to first child ( temp float)
+0:13        'output2' (layout( stream=0) out float)
+0:13        Constant:
+0:13          2.000000
+0:14      EmitStreamVertex ( global void)
+0:14        Constant:
+0:14          0 (const int)
+0:15      EndStreamPrimitive ( global void)
+0:15        Constant:
+0:15          0 (const int)
+0:16      move second child to first child ( temp float)
+0:16        'output3' (layout( stream=1) out float)
+0:16        Constant:
+0:16          3.000000
+0:17      move second child to first child ( temp float)
+0:17        'output4' (layout( stream=1) out float)
+0:17        Constant:
+0:17          4.000000
+0:18      EmitStreamVertex ( global void)
+0:18        Constant:
+0:18          1 (const int)
+0:19      EndStreamPrimitive ( global void)
+0:19        Constant:
+0:19          1 (const int)
+0:?   Linker Objects
+0:?     'output1' (layout( stream=0) out float)
+0:?     'output2' (layout( stream=0) out float)
+0:?     'output3' (layout( stream=1) out float)
+0:?     'output4' (layout( stream=1) out float)
+0:?     'stream' ( uniform uint)
+
+
+Linked geometry stage:
+
+
+Shader version: 150
+Requested GL_ARB_gpu_shader5
+invocations = 1
+max_vertices = 1
+input primitive = points
+output primitive = points
+0:? Sequence
+0:10  Function Definition: main( ( global void)
+0:10    Function Parameters: 
+0:12    Sequence
+0:12      move second child to first child ( temp float)
+0:12        'output1' (layout( stream=0) out float)
+0:12        Constant:
+0:12          1.000000
+0:13      move second child to first child ( temp float)
+0:13        'output2' (layout( stream=0) out float)
+0:13        Constant:
+0:13          2.000000
+0:14      EmitStreamVertex ( global void)
+0:14        Constant:
+0:14          0 (const int)
+0:15      EndStreamPrimitive ( global void)
+0:15        Constant:
+0:15          0 (const int)
+0:16      move second child to first child ( temp float)
+0:16        'output3' (layout( stream=1) out float)
+0:16        Constant:
+0:16          3.000000
+0:17      move second child to first child ( temp float)
+0:17        'output4' (layout( stream=1) out float)
+0:17        Constant:
+0:17          4.000000
+0:18      EmitStreamVertex ( global void)
+0:18        Constant:
+0:18          1 (const int)
+0:19      EndStreamPrimitive ( global void)
+0:19        Constant:
+0:19          1 (const int)
+0:?   Linker Objects
+0:?     'output1' (layout( stream=0) out float)
+0:?     'output2' (layout( stream=0) out float)
+0:?     'output3' (layout( stream=1) out float)
+0:?     'output4' (layout( stream=1) out float)
+0:?     'stream' ( uniform uint)
+
diff --git a/Test/baseResults/GL_ARB_fragment_coord_conventions.vert.out b/Test/baseResults/GL_ARB_fragment_coord_conventions.vert.out
new file mode 100644
index 0000000..3b55ae0
--- /dev/null
+++ b/Test/baseResults/GL_ARB_fragment_coord_conventions.vert.out
@@ -0,0 +1,143 @@
+GL_ARB_fragment_coord_conventions.vert
+Shader version: 140
+Requested GL_ARB_explicit_attrib_location
+Requested GL_ARB_fragment_coord_conventions
+0:? Sequence
+0:22  Function Definition: main( ( global void)
+0:22    Function Parameters: 
+0:24    Sequence
+0:24      move second child to first child ( temp 4-component vector of float)
+0:24        'gl_Position' ( gl_Position 4-component vector of float Position)
+0:24        'pos' (layout( location=0) in 4-component vector of float)
+0:25      move second child to first child ( temp 4-component vector of float)
+0:25        'i' ( smooth out 4-component vector of float)
+0:25        Construct vec4 ( temp 4-component vector of float)
+0:25          component-wise multiply ( temp float)
+0:25            component-wise multiply ( temp float)
+0:25              add ( temp float)
+0:25                direct index ( temp float)
+0:25                  'pos' (layout( location=0) in 4-component vector of float)
+0:25                  Constant:
+0:25                    0 (const int)
+0:25                Constant:
+0:25                  1.000000
+0:25              Constant:
+0:25                0.500000
+0:25            'gtf_windowWidth' ( uniform float)
+0:25          component-wise multiply ( temp float)
+0:25            component-wise multiply ( temp float)
+0:25              add ( temp float)
+0:25                direct index ( temp float)
+0:25                  'pos' (layout( location=0) in 4-component vector of float)
+0:25                  Constant:
+0:25                    1 (const int)
+0:25                Constant:
+0:25                  1.000000
+0:25              Constant:
+0:25                0.500000
+0:25            'gtf_windowHeight' ( uniform float)
+0:25          add ( temp float)
+0:25            component-wise multiply ( temp float)
+0:25              component-wise multiply ( temp float)
+0:25                subtract ( temp float)
+0:25                  'f' ( uniform float)
+0:25                  'n' ( uniform float)
+0:25                Constant:
+0:25                  0.500000
+0:25              direct index ( temp float)
+0:25                'pos' (layout( location=0) in 4-component vector of float)
+0:25                Constant:
+0:25                  2 (const int)
+0:25            component-wise multiply ( temp float)
+0:25              add ( temp float)
+0:25                'f' ( uniform float)
+0:25                'n' ( uniform float)
+0:25              Constant:
+0:25                0.500000
+0:25          direct index ( temp float)
+0:25            'pos' (layout( location=0) in 4-component vector of float)
+0:25            Constant:
+0:25              3 (const int)
+0:?   Linker Objects
+0:?     'pos' (layout( location=0) in 4-component vector of float)
+0:?     'i' ( smooth out 4-component vector of float)
+0:?     'gtf_windowWidth' ( uniform float)
+0:?     'gtf_windowHeight' ( uniform float)
+0:?     'n' ( uniform float)
+0:?     'f' ( uniform float)
+0:?     'gl_VertexID' ( gl_VertexId int VertexId)
+0:?     'gl_InstanceID' ( gl_InstanceId int InstanceId)
+
+
+Linked vertex stage:
+
+
+Shader version: 140
+Requested GL_ARB_explicit_attrib_location
+Requested GL_ARB_fragment_coord_conventions
+0:? Sequence
+0:22  Function Definition: main( ( global void)
+0:22    Function Parameters: 
+0:24    Sequence
+0:24      move second child to first child ( temp 4-component vector of float)
+0:24        'gl_Position' ( gl_Position 4-component vector of float Position)
+0:24        'pos' (layout( location=0) in 4-component vector of float)
+0:25      move second child to first child ( temp 4-component vector of float)
+0:25        'i' ( smooth out 4-component vector of float)
+0:25        Construct vec4 ( temp 4-component vector of float)
+0:25          component-wise multiply ( temp float)
+0:25            component-wise multiply ( temp float)
+0:25              add ( temp float)
+0:25                direct index ( temp float)
+0:25                  'pos' (layout( location=0) in 4-component vector of float)
+0:25                  Constant:
+0:25                    0 (const int)
+0:25                Constant:
+0:25                  1.000000
+0:25              Constant:
+0:25                0.500000
+0:25            'gtf_windowWidth' ( uniform float)
+0:25          component-wise multiply ( temp float)
+0:25            component-wise multiply ( temp float)
+0:25              add ( temp float)
+0:25                direct index ( temp float)
+0:25                  'pos' (layout( location=0) in 4-component vector of float)
+0:25                  Constant:
+0:25                    1 (const int)
+0:25                Constant:
+0:25                  1.000000
+0:25              Constant:
+0:25                0.500000
+0:25            'gtf_windowHeight' ( uniform float)
+0:25          add ( temp float)
+0:25            component-wise multiply ( temp float)
+0:25              component-wise multiply ( temp float)
+0:25                subtract ( temp float)
+0:25                  'f' ( uniform float)
+0:25                  'n' ( uniform float)
+0:25                Constant:
+0:25                  0.500000
+0:25              direct index ( temp float)
+0:25                'pos' (layout( location=0) in 4-component vector of float)
+0:25                Constant:
+0:25                  2 (const int)
+0:25            component-wise multiply ( temp float)
+0:25              add ( temp float)
+0:25                'f' ( uniform float)
+0:25                'n' ( uniform float)
+0:25              Constant:
+0:25                0.500000
+0:25          direct index ( temp float)
+0:25            'pos' (layout( location=0) in 4-component vector of float)
+0:25            Constant:
+0:25              3 (const int)
+0:?   Linker Objects
+0:?     'pos' (layout( location=0) in 4-component vector of float)
+0:?     'i' ( smooth out 4-component vector of float)
+0:?     'gtf_windowWidth' ( uniform float)
+0:?     'gtf_windowHeight' ( uniform float)
+0:?     'n' ( uniform float)
+0:?     'f' ( uniform float)
+0:?     'gl_VertexID' ( gl_VertexId int VertexId)
+0:?     'gl_InstanceID' ( gl_InstanceId int InstanceId)
+
diff --git a/Test/baseResults/compoundsuffix.frag.hlsl b/Test/baseResults/compoundsuffix.frag.hlsl
index 5a62488..f8dcfaa 100644
--- a/Test/baseResults/compoundsuffix.frag.hlsl
+++ b/Test/baseResults/compoundsuffix.frag.hlsl
@@ -1,45 +1,45 @@
-compoundsuffix.frag.hlsl

-// Module Version 10000

-// Generated by (magic number): 8000a

-// Id's are bound by 22

-

-                              Capability Shader

-               1:             ExtInstImport  "GLSL.std.450"

-                              MemoryModel Logical GLSL450

-                              EntryPoint Fragment 4  "main" 20

-                              ExecutionMode 4 OriginUpperLeft

-                              Source HLSL 500

-                              Name 4  "main"

-                              Name 11  "@main(vf4;"

-                              Name 10  "fragColor"

-                              Name 15  "fragColor"

-                              Name 16  "param"

-                              Name 20  "fragColor"

-                              Decorate 20(fragColor) Location 0

-               2:             TypeVoid

-               3:             TypeFunction 2

-               6:             TypeFloat 32

-               7:             TypeVector 6(float) 4

-               8:             TypePointer Function 7(fvec4)

-               9:             TypeFunction 2 8(ptr)

-              13:    6(float) Constant 1065353216

-              14:    7(fvec4) ConstantComposite 13 13 13 13

-              19:             TypePointer Output 7(fvec4)

-   20(fragColor):     19(ptr) Variable Output

-         4(main):           2 Function None 3

-               5:             Label

-   15(fragColor):      8(ptr) Variable Function

-       16(param):      8(ptr) Variable Function

-              17:           2 FunctionCall 11(@main(vf4;) 16(param)

-              18:    7(fvec4) Load 16(param)

-                              Store 15(fragColor) 18

-              21:    7(fvec4) Load 15(fragColor)

-                              Store 20(fragColor) 21

-                              Return

-                              FunctionEnd

-  11(@main(vf4;):           2 Function None 9

-   10(fragColor):      8(ptr) FunctionParameter

-              12:             Label

-                              Store 10(fragColor) 14

-                              Return

-                              FunctionEnd

+compoundsuffix.frag.hlsl
+// Module Version 10000
+// Generated by (magic number): 8000b
+// Id's are bound by 22
+
+                              Capability Shader
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel Logical GLSL450
+                              EntryPoint Fragment 4  "main" 20
+                              ExecutionMode 4 OriginUpperLeft
+                              Source HLSL 500
+                              Name 4  "main"
+                              Name 11  "@main(vf4;"
+                              Name 10  "fragColor"
+                              Name 15  "fragColor"
+                              Name 16  "param"
+                              Name 20  "fragColor"
+                              Decorate 20(fragColor) Location 0
+               2:             TypeVoid
+               3:             TypeFunction 2
+               6:             TypeFloat 32
+               7:             TypeVector 6(float) 4
+               8:             TypePointer Function 7(fvec4)
+               9:             TypeFunction 2 8(ptr)
+              13:    6(float) Constant 1065353216
+              14:    7(fvec4) ConstantComposite 13 13 13 13
+              19:             TypePointer Output 7(fvec4)
+   20(fragColor):     19(ptr) Variable Output
+         4(main):           2 Function None 3
+               5:             Label
+   15(fragColor):      8(ptr) Variable Function
+       16(param):      8(ptr) Variable Function
+              17:           2 FunctionCall 11(@main(vf4;) 16(param)
+              18:    7(fvec4) Load 16(param)
+                              Store 15(fragColor) 18
+              21:    7(fvec4) Load 15(fragColor)
+                              Store 20(fragColor) 21
+                              Return
+                              FunctionEnd
+  11(@main(vf4;):           2 Function None 9
+   10(fragColor):      8(ptr) FunctionParameter
+              12:             Label
+                              Store 10(fragColor) 14
+                              Return
+                              FunctionEnd
diff --git a/Test/baseResults/compoundsuffix.vert.glsl b/Test/baseResults/compoundsuffix.vert.glsl
index 58354a4..8535b47 100644
--- a/Test/baseResults/compoundsuffix.vert.glsl
+++ b/Test/baseResults/compoundsuffix.vert.glsl
@@ -1,15 +1,15 @@
-compoundsuffix.vert.glsl

-Shader version: 100

-0:? Sequence

-0:1  Function Definition: main( ( global void)

-0:1    Function Parameters: 

-0:3    Sequence

-0:3      move second child to first child ( temp highp 4-component vector of float)

-0:3        'gl_Position' ( gl_Position highp 4-component vector of float Position)

-0:3        Constant:

-0:3          1.000000

-0:3          1.000000

-0:3          1.000000

-0:3          1.000000

-0:?   Linker Objects

-

+compoundsuffix.vert.glsl
+Shader version: 100
+0:? Sequence
+0:1  Function Definition: main( ( global void)
+0:1    Function Parameters: 
+0:3    Sequence
+0:3      move second child to first child ( temp highp 4-component vector of float)
+0:3        'gl_Position' ( gl_Position highp 4-component vector of float Position)
+0:3        Constant:
+0:3          1.000000
+0:3          1.000000
+0:3          1.000000
+0:3          1.000000
+0:?   Linker Objects
+
diff --git a/Test/baseResults/constantUnaryConversion.comp.out b/Test/baseResults/constantUnaryConversion.comp.out
index fcaf6f2..78372f0 100644
--- a/Test/baseResults/constantUnaryConversion.comp.out
+++ b/Test/baseResults/constantUnaryConversion.comp.out
@@ -3,8 +3,8 @@
 Requested GL_EXT_shader_explicit_arithmetic_types
 local_size = (1, 1, 1)
 0:? Sequence
-0:48  Function Definition: main( ( global void)
-0:48    Function Parameters: 
+0:69  Function Definition: main( ( global void)
+0:69    Function Parameters: 
 0:?   Linker Objects
 0:?     'bool_init' ( const bool)
 0:?       true (const bool)
@@ -29,6 +29,12 @@
 0:?     'float32_t_init' ( const float)
 0:?       13.000000
 0:?     'float64_t_init' ( const double)
+0:?       4.000000
+0:?     'neg_float16_t_init' ( const float16_t)
+0:?       -42.000000
+0:?     'neg_float32_t_init' ( const float)
+0:?       -13.000000
+0:?     'neg_float64_t_init' ( const double)
 0:?       -4.000000
 0:?     'bool_to_bool' ( const bool)
 0:?       true (const bool)
@@ -77,7 +83,7 @@
 0:?     'float32_t_to_int8_t' ( const int8_t)
 0:?       13 (const int8_t)
 0:?     'float64_t_to_int8_t' ( const int8_t)
-0:?       -4 (const int8_t)
+0:?       4 (const int8_t)
 0:?     'bool_to_int16_t' ( const int16_t)
 0:?       1 (const int16_t)
 0:?     'int8_t_to_int16_t' ( const int16_t)
@@ -101,7 +107,7 @@
 0:?     'float32_t_to_int16_t' ( const int16_t)
 0:?       13 (const int16_t)
 0:?     'float64_t_to_int16_t' ( const int16_t)
-0:?       -4 (const int16_t)
+0:?       4 (const int16_t)
 0:?     'bool_to_int32_t' ( const int)
 0:?       1 (const int)
 0:?     'int8_t_to_int32_t' ( const int)
@@ -125,7 +131,7 @@
 0:?     'float32_t_to_int32_t' ( const int)
 0:?       13 (const int)
 0:?     'float64_t_to_int32_t' ( const int)
-0:?       -4 (const int)
+0:?       4 (const int)
 0:?     'bool_to_int64_t' ( const int64_t)
 0:?       1 (const int64_t)
 0:?     'int8_t_to_int64_t' ( const int64_t)
@@ -149,7 +155,7 @@
 0:?     'float32_t_to_int64_t' ( const int64_t)
 0:?       13 (const int64_t)
 0:?     'float64_t_to_int64_t' ( const int64_t)
-0:?       -4 (const int64_t)
+0:?       4 (const int64_t)
 0:?     'bool_to_uint8_t' ( const uint8_t)
 0:?       1 (const uint8_t)
 0:?     'int8_t_to_uint8_t' ( const uint8_t)
@@ -173,7 +179,7 @@
 0:?     'float32_t_to_uint8_t' ( const uint8_t)
 0:?       13 (const uint8_t)
 0:?     'float64_t_to_uint8_t' ( const uint8_t)
-0:?       252 (const uint8_t)
+0:?       4 (const uint8_t)
 0:?     'bool_to_uint16_t' ( const uint16_t)
 0:?       1 (const uint16_t)
 0:?     'int8_t_to_uint16_t' ( const uint16_t)
@@ -197,7 +203,7 @@
 0:?     'float32_t_to_uint16_t' ( const uint16_t)
 0:?       13 (const uint16_t)
 0:?     'float64_t_to_uint16_t' ( const uint16_t)
-0:?       65532 (const uint16_t)
+0:?       4 (const uint16_t)
 0:?     'bool_to_uint32_t' ( const uint)
 0:?       1 (const uint)
 0:?     'int8_t_to_uint32_t' ( const uint)
@@ -221,7 +227,7 @@
 0:?     'float32_t_to_uint32_t' ( const uint)
 0:?       13 (const uint)
 0:?     'float64_t_to_uint32_t' ( const uint)
-0:?       4294967292 (const uint)
+0:?       4 (const uint)
 0:?     'bool_to_uint64_t' ( const uint64_t)
 0:?       1 (const uint64_t)
 0:?     'int8_t_to_uint64_t' ( const uint64_t)
@@ -245,7 +251,7 @@
 0:?     'float32_t_to_uint64_t' ( const uint64_t)
 0:?       13 (const uint64_t)
 0:?     'float64_t_to_uint64_t' ( const uint64_t)
-0:?       18446744073709551612 (const uint64_t)
+0:?       4 (const uint64_t)
 0:?     'bool_to_float16_t' ( const float16_t)
 0:?       1.000000
 0:?     'int8_t_to_float16_t' ( const float16_t)
@@ -269,7 +275,7 @@
 0:?     'float32_t_to_float16_t' ( const float16_t)
 0:?       13.000000
 0:?     'float64_t_to_float16_t' ( const float16_t)
-0:?       -4.000000
+0:?       4.000000
 0:?     'bool_to_float32_t' ( const float)
 0:?       1.000000
 0:?     'int8_t_to_float32_t' ( const float)
@@ -293,7 +299,7 @@
 0:?     'float32_t_to_float32_t' ( const float)
 0:?       13.000000
 0:?     'float64_t_to_float32_t' ( const float)
-0:?       -4.000000
+0:?       4.000000
 0:?     'bool_to_float64_t' ( const double)
 0:?       1.000000
 0:?     'int8_t_to_float64_t' ( const double)
@@ -317,6 +323,54 @@
 0:?     'float32_t_to_float64_t' ( const double)
 0:?       13.000000
 0:?     'float64_t_to_float64_t' ( const double)
+0:?       4.000000
+0:?     'neg_float16_t_to_bool' ( const bool)
+0:?       true (const bool)
+0:?     'neg_float32_t_to_bool' ( const bool)
+0:?       true (const bool)
+0:?     'neg_float64_t_to_bool' ( const bool)
+0:?       true (const bool)
+0:?     'neg_float16_t_to_int8_t' ( const int8_t)
+0:?       -42 (const int8_t)
+0:?     'neg_float32_t_to_int8_t' ( const int8_t)
+0:?       -13 (const int8_t)
+0:?     'neg_float64_t_to_int8_t' ( const int8_t)
+0:?       -4 (const int8_t)
+0:?     'neg_float16_t_to_int16_t' ( const int16_t)
+0:?       -42 (const int16_t)
+0:?     'neg_float32_t_to_int16_t' ( const int16_t)
+0:?       -13 (const int16_t)
+0:?     'neg_float64_t_to_int16_t' ( const int16_t)
+0:?       -4 (const int16_t)
+0:?     'neg_float16_t_to_int32_t' ( const int)
+0:?       -42 (const int)
+0:?     'neg_float32_t_to_int32_t' ( const int)
+0:?       -13 (const int)
+0:?     'neg_float64_t_to_int32_t' ( const int)
+0:?       -4 (const int)
+0:?     'neg_float16_t_to_int64_t' ( const int64_t)
+0:?       -42 (const int64_t)
+0:?     'neg_float32_t_to_int64_t' ( const int64_t)
+0:?       -13 (const int64_t)
+0:?     'neg_float64_t_to_int64_t' ( const int64_t)
+0:?       -4 (const int64_t)
+0:?     'neg_float16_t_to_float16_t' ( const float16_t)
+0:?       -42.000000
+0:?     'neg_float32_t_to_float16_t' ( const float16_t)
+0:?       -13.000000
+0:?     'neg_float64_t_to_float16_t' ( const float16_t)
+0:?       -4.000000
+0:?     'neg_float16_t_to_float32_t' ( const float)
+0:?       -42.000000
+0:?     'neg_float32_t_to_float32_t' ( const float)
+0:?       -13.000000
+0:?     'neg_float64_t_to_float32_t' ( const float)
+0:?       -4.000000
+0:?     'neg_float16_t_to_float64_t' ( const double)
+0:?       -42.000000
+0:?     'neg_float32_t_to_float64_t' ( const double)
+0:?       -13.000000
+0:?     'neg_float64_t_to_float64_t' ( const double)
 0:?       -4.000000
 
 
@@ -327,8 +381,8 @@
 Requested GL_EXT_shader_explicit_arithmetic_types
 local_size = (1, 1, 1)
 0:? Sequence
-0:48  Function Definition: main( ( global void)
-0:48    Function Parameters: 
+0:69  Function Definition: main( ( global void)
+0:69    Function Parameters: 
 0:?   Linker Objects
 0:?     'bool_init' ( const bool)
 0:?       true (const bool)
@@ -353,6 +407,12 @@
 0:?     'float32_t_init' ( const float)
 0:?       13.000000
 0:?     'float64_t_init' ( const double)
+0:?       4.000000
+0:?     'neg_float16_t_init' ( const float16_t)
+0:?       -42.000000
+0:?     'neg_float32_t_init' ( const float)
+0:?       -13.000000
+0:?     'neg_float64_t_init' ( const double)
 0:?       -4.000000
 0:?     'bool_to_bool' ( const bool)
 0:?       true (const bool)
@@ -401,7 +461,7 @@
 0:?     'float32_t_to_int8_t' ( const int8_t)
 0:?       13 (const int8_t)
 0:?     'float64_t_to_int8_t' ( const int8_t)
-0:?       -4 (const int8_t)
+0:?       4 (const int8_t)
 0:?     'bool_to_int16_t' ( const int16_t)
 0:?       1 (const int16_t)
 0:?     'int8_t_to_int16_t' ( const int16_t)
@@ -425,7 +485,7 @@
 0:?     'float32_t_to_int16_t' ( const int16_t)
 0:?       13 (const int16_t)
 0:?     'float64_t_to_int16_t' ( const int16_t)
-0:?       -4 (const int16_t)
+0:?       4 (const int16_t)
 0:?     'bool_to_int32_t' ( const int)
 0:?       1 (const int)
 0:?     'int8_t_to_int32_t' ( const int)
@@ -449,7 +509,7 @@
 0:?     'float32_t_to_int32_t' ( const int)
 0:?       13 (const int)
 0:?     'float64_t_to_int32_t' ( const int)
-0:?       -4 (const int)
+0:?       4 (const int)
 0:?     'bool_to_int64_t' ( const int64_t)
 0:?       1 (const int64_t)
 0:?     'int8_t_to_int64_t' ( const int64_t)
@@ -473,7 +533,7 @@
 0:?     'float32_t_to_int64_t' ( const int64_t)
 0:?       13 (const int64_t)
 0:?     'float64_t_to_int64_t' ( const int64_t)
-0:?       -4 (const int64_t)
+0:?       4 (const int64_t)
 0:?     'bool_to_uint8_t' ( const uint8_t)
 0:?       1 (const uint8_t)
 0:?     'int8_t_to_uint8_t' ( const uint8_t)
@@ -497,7 +557,7 @@
 0:?     'float32_t_to_uint8_t' ( const uint8_t)
 0:?       13 (const uint8_t)
 0:?     'float64_t_to_uint8_t' ( const uint8_t)
-0:?       252 (const uint8_t)
+0:?       4 (const uint8_t)
 0:?     'bool_to_uint16_t' ( const uint16_t)
 0:?       1 (const uint16_t)
 0:?     'int8_t_to_uint16_t' ( const uint16_t)
@@ -521,7 +581,7 @@
 0:?     'float32_t_to_uint16_t' ( const uint16_t)
 0:?       13 (const uint16_t)
 0:?     'float64_t_to_uint16_t' ( const uint16_t)
-0:?       65532 (const uint16_t)
+0:?       4 (const uint16_t)
 0:?     'bool_to_uint32_t' ( const uint)
 0:?       1 (const uint)
 0:?     'int8_t_to_uint32_t' ( const uint)
@@ -545,7 +605,7 @@
 0:?     'float32_t_to_uint32_t' ( const uint)
 0:?       13 (const uint)
 0:?     'float64_t_to_uint32_t' ( const uint)
-0:?       4294967292 (const uint)
+0:?       4 (const uint)
 0:?     'bool_to_uint64_t' ( const uint64_t)
 0:?       1 (const uint64_t)
 0:?     'int8_t_to_uint64_t' ( const uint64_t)
@@ -569,7 +629,7 @@
 0:?     'float32_t_to_uint64_t' ( const uint64_t)
 0:?       13 (const uint64_t)
 0:?     'float64_t_to_uint64_t' ( const uint64_t)
-0:?       18446744073709551612 (const uint64_t)
+0:?       4 (const uint64_t)
 0:?     'bool_to_float16_t' ( const float16_t)
 0:?       1.000000
 0:?     'int8_t_to_float16_t' ( const float16_t)
@@ -593,7 +653,7 @@
 0:?     'float32_t_to_float16_t' ( const float16_t)
 0:?       13.000000
 0:?     'float64_t_to_float16_t' ( const float16_t)
-0:?       -4.000000
+0:?       4.000000
 0:?     'bool_to_float32_t' ( const float)
 0:?       1.000000
 0:?     'int8_t_to_float32_t' ( const float)
@@ -617,7 +677,7 @@
 0:?     'float32_t_to_float32_t' ( const float)
 0:?       13.000000
 0:?     'float64_t_to_float32_t' ( const float)
-0:?       -4.000000
+0:?       4.000000
 0:?     'bool_to_float64_t' ( const double)
 0:?       1.000000
 0:?     'int8_t_to_float64_t' ( const double)
@@ -641,5 +701,53 @@
 0:?     'float32_t_to_float64_t' ( const double)
 0:?       13.000000
 0:?     'float64_t_to_float64_t' ( const double)
+0:?       4.000000
+0:?     'neg_float16_t_to_bool' ( const bool)
+0:?       true (const bool)
+0:?     'neg_float32_t_to_bool' ( const bool)
+0:?       true (const bool)
+0:?     'neg_float64_t_to_bool' ( const bool)
+0:?       true (const bool)
+0:?     'neg_float16_t_to_int8_t' ( const int8_t)
+0:?       -42 (const int8_t)
+0:?     'neg_float32_t_to_int8_t' ( const int8_t)
+0:?       -13 (const int8_t)
+0:?     'neg_float64_t_to_int8_t' ( const int8_t)
+0:?       -4 (const int8_t)
+0:?     'neg_float16_t_to_int16_t' ( const int16_t)
+0:?       -42 (const int16_t)
+0:?     'neg_float32_t_to_int16_t' ( const int16_t)
+0:?       -13 (const int16_t)
+0:?     'neg_float64_t_to_int16_t' ( const int16_t)
+0:?       -4 (const int16_t)
+0:?     'neg_float16_t_to_int32_t' ( const int)
+0:?       -42 (const int)
+0:?     'neg_float32_t_to_int32_t' ( const int)
+0:?       -13 (const int)
+0:?     'neg_float64_t_to_int32_t' ( const int)
+0:?       -4 (const int)
+0:?     'neg_float16_t_to_int64_t' ( const int64_t)
+0:?       -42 (const int64_t)
+0:?     'neg_float32_t_to_int64_t' ( const int64_t)
+0:?       -13 (const int64_t)
+0:?     'neg_float64_t_to_int64_t' ( const int64_t)
+0:?       -4 (const int64_t)
+0:?     'neg_float16_t_to_float16_t' ( const float16_t)
+0:?       -42.000000
+0:?     'neg_float32_t_to_float16_t' ( const float16_t)
+0:?       -13.000000
+0:?     'neg_float64_t_to_float16_t' ( const float16_t)
+0:?       -4.000000
+0:?     'neg_float16_t_to_float32_t' ( const float)
+0:?       -42.000000
+0:?     'neg_float32_t_to_float32_t' ( const float)
+0:?       -13.000000
+0:?     'neg_float64_t_to_float32_t' ( const float)
+0:?       -4.000000
+0:?     'neg_float16_t_to_float64_t' ( const double)
+0:?       -42.000000
+0:?     'neg_float32_t_to_float64_t' ( const double)
+0:?       -13.000000
+0:?     'neg_float64_t_to_float64_t' ( const double)
 0:?       -4.000000
 
diff --git a/Test/baseResults/coord_conventions.frag.out b/Test/baseResults/coord_conventions.frag.out
new file mode 100644
index 0000000..656c608
--- /dev/null
+++ b/Test/baseResults/coord_conventions.frag.out
@@ -0,0 +1,255 @@
+coord_conventions.frag
+Shader version: 140
+Requested GL_ARB_explicit_attrib_location
+Requested GL_ARB_fragment_coord_conventions
+gl_FragCoord pixel center is integer
+gl_FragCoord origin is upper left
+0:? Sequence
+0:17  Function Definition: main( ( global void)
+0:17    Function Parameters: 
+0:19    Sequence
+0:19      move second child to first child ( temp 4-component vector of float)
+0:19        'myColor' (layout( location=0) out 4-component vector of float)
+0:19        Constant:
+0:19          0.200000
+0:19          0.200000
+0:19          0.200000
+0:19          0.200000
+0:20      Test condition and select ( temp void)
+0:20        Condition
+0:20        Compare Greater Than or Equal ( temp bool)
+0:20          direct index ( temp float)
+0:20            'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:20            Constant:
+0:20              1 (const int)
+0:20          Constant:
+0:20            10.000000
+0:20        true case
+0:21        Sequence
+0:21          move second child to first child ( temp float)
+0:21            direct index ( temp float)
+0:21              'myColor' (layout( location=0) out 4-component vector of float)
+0:21              Constant:
+0:21                2 (const int)
+0:21            Constant:
+0:21              0.800000
+0:23      Test condition and select ( temp void)
+0:23        Condition
+0:23        Compare Equal ( temp bool)
+0:23          direct index ( temp float)
+0:23            'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:23            Constant:
+0:23              1 (const int)
+0:23          trunc ( global float)
+0:23            direct index ( temp float)
+0:23              'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:23              Constant:
+0:23                1 (const int)
+0:23        true case
+0:24        Sequence
+0:24          move second child to first child ( temp float)
+0:24            direct index ( temp float)
+0:24              'myColor' (layout( location=0) out 4-component vector of float)
+0:24              Constant:
+0:24                1 (const int)
+0:24            Constant:
+0:24              0.800000
+0:26      Test condition and select ( temp void)
+0:26        Condition
+0:26        Compare Equal ( temp bool)
+0:26          direct index ( temp float)
+0:26            'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:26            Constant:
+0:26              0 (const int)
+0:26          trunc ( global float)
+0:26            direct index ( temp float)
+0:26              'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:26              Constant:
+0:26                0 (const int)
+0:26        true case
+0:27        Sequence
+0:27          move second child to first child ( temp float)
+0:27            direct index ( temp float)
+0:27              'myColor' (layout( location=0) out 4-component vector of float)
+0:27              Constant:
+0:27                0 (const int)
+0:27            Constant:
+0:27              0.800000
+0:30      Sequence
+0:30        move second child to first child ( temp 4-component vector of float)
+0:30          'diff' ( temp 4-component vector of float)
+0:30          subtract ( temp 4-component vector of float)
+0:30            'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:30            'i' ( smooth in 4-component vector of float)
+0:31      Test condition and select ( temp void)
+0:31        Condition
+0:31        Compare Greater Than ( temp bool)
+0:31          Absolute value ( global float)
+0:31            direct index ( temp float)
+0:31              'diff' ( temp 4-component vector of float)
+0:31              Constant:
+0:31                2 (const int)
+0:31          Constant:
+0:31            0.001000
+0:31        true case
+0:32        move second child to first child ( temp float)
+0:32          direct index ( temp float)
+0:32            'myColor' (layout( location=0) out 4-component vector of float)
+0:32            Constant:
+0:32              2 (const int)
+0:32          Constant:
+0:32            0.500000
+0:33      Test condition and select ( temp void)
+0:33        Condition
+0:33        Compare Greater Than ( temp bool)
+0:33          Absolute value ( global float)
+0:33            direct index ( temp float)
+0:33              'diff' ( temp 4-component vector of float)
+0:33              Constant:
+0:33                3 (const int)
+0:33          Constant:
+0:33            0.001000
+0:33        true case
+0:34        move second child to first child ( temp float)
+0:34          direct index ( temp float)
+0:34            'myColor' (layout( location=0) out 4-component vector of float)
+0:34            Constant:
+0:34              3 (const int)
+0:34          Constant:
+0:34            0.500000
+0:?   Linker Objects
+0:?     'i' ( smooth in 4-component vector of float)
+0:?     'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:?     'myColor' (layout( location=0) out 4-component vector of float)
+0:?     'eps' ( const float)
+0:?       0.001000
+
+
+Linked fragment stage:
+
+
+Shader version: 140
+Requested GL_ARB_explicit_attrib_location
+Requested GL_ARB_fragment_coord_conventions
+gl_FragCoord pixel center is integer
+gl_FragCoord origin is upper left
+0:? Sequence
+0:17  Function Definition: main( ( global void)
+0:17    Function Parameters: 
+0:19    Sequence
+0:19      move second child to first child ( temp 4-component vector of float)
+0:19        'myColor' (layout( location=0) out 4-component vector of float)
+0:19        Constant:
+0:19          0.200000
+0:19          0.200000
+0:19          0.200000
+0:19          0.200000
+0:20      Test condition and select ( temp void)
+0:20        Condition
+0:20        Compare Greater Than or Equal ( temp bool)
+0:20          direct index ( temp float)
+0:20            'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:20            Constant:
+0:20              1 (const int)
+0:20          Constant:
+0:20            10.000000
+0:20        true case
+0:21        Sequence
+0:21          move second child to first child ( temp float)
+0:21            direct index ( temp float)
+0:21              'myColor' (layout( location=0) out 4-component vector of float)
+0:21              Constant:
+0:21                2 (const int)
+0:21            Constant:
+0:21              0.800000
+0:23      Test condition and select ( temp void)
+0:23        Condition
+0:23        Compare Equal ( temp bool)
+0:23          direct index ( temp float)
+0:23            'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:23            Constant:
+0:23              1 (const int)
+0:23          trunc ( global float)
+0:23            direct index ( temp float)
+0:23              'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:23              Constant:
+0:23                1 (const int)
+0:23        true case
+0:24        Sequence
+0:24          move second child to first child ( temp float)
+0:24            direct index ( temp float)
+0:24              'myColor' (layout( location=0) out 4-component vector of float)
+0:24              Constant:
+0:24                1 (const int)
+0:24            Constant:
+0:24              0.800000
+0:26      Test condition and select ( temp void)
+0:26        Condition
+0:26        Compare Equal ( temp bool)
+0:26          direct index ( temp float)
+0:26            'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:26            Constant:
+0:26              0 (const int)
+0:26          trunc ( global float)
+0:26            direct index ( temp float)
+0:26              'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:26              Constant:
+0:26                0 (const int)
+0:26        true case
+0:27        Sequence
+0:27          move second child to first child ( temp float)
+0:27            direct index ( temp float)
+0:27              'myColor' (layout( location=0) out 4-component vector of float)
+0:27              Constant:
+0:27                0 (const int)
+0:27            Constant:
+0:27              0.800000
+0:30      Sequence
+0:30        move second child to first child ( temp 4-component vector of float)
+0:30          'diff' ( temp 4-component vector of float)
+0:30          subtract ( temp 4-component vector of float)
+0:30            'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:30            'i' ( smooth in 4-component vector of float)
+0:31      Test condition and select ( temp void)
+0:31        Condition
+0:31        Compare Greater Than ( temp bool)
+0:31          Absolute value ( global float)
+0:31            direct index ( temp float)
+0:31              'diff' ( temp 4-component vector of float)
+0:31              Constant:
+0:31                2 (const int)
+0:31          Constant:
+0:31            0.001000
+0:31        true case
+0:32        move second child to first child ( temp float)
+0:32          direct index ( temp float)
+0:32            'myColor' (layout( location=0) out 4-component vector of float)
+0:32            Constant:
+0:32              2 (const int)
+0:32          Constant:
+0:32            0.500000
+0:33      Test condition and select ( temp void)
+0:33        Condition
+0:33        Compare Greater Than ( temp bool)
+0:33          Absolute value ( global float)
+0:33            direct index ( temp float)
+0:33              'diff' ( temp 4-component vector of float)
+0:33              Constant:
+0:33                3 (const int)
+0:33          Constant:
+0:33            0.001000
+0:33        true case
+0:34        move second child to first child ( temp float)
+0:34          direct index ( temp float)
+0:34            'myColor' (layout( location=0) out 4-component vector of float)
+0:34            Constant:
+0:34              3 (const int)
+0:34          Constant:
+0:34            0.500000
+0:?   Linker Objects
+0:?     'i' ( smooth in 4-component vector of float)
+0:?     'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:?     'myColor' (layout( location=0) out 4-component vector of float)
+0:?     'eps' ( const float)
+0:?       0.001000
+
diff --git a/Test/baseResults/enhanced.0.frag.out b/Test/baseResults/enhanced.0.frag.out
new file mode 100644
index 0000000..1171bfa
--- /dev/null
+++ b/Test/baseResults/enhanced.0.frag.out
@@ -0,0 +1,6 @@
+enhanced.0.frag
+ERROR: enhanced.0.frag:7: ' vec4 constructor' : not enough data provided for construction 
+ERROR: 1 compilation errors.  No code generated.
+
+
+SPIR-V is not generated for failed compile or link
diff --git a/Test/baseResults/enhanced.1.frag.out b/Test/baseResults/enhanced.1.frag.out
new file mode 100644
index 0000000..42f5b72
--- /dev/null
+++ b/Test/baseResults/enhanced.1.frag.out
@@ -0,0 +1,6 @@
+enhanced.1.frag
+ERROR: enhanced.1.frag:9: 'v2' : no such field in structure 'vVert'
+ERROR: 1 compilation errors.  No code generated.
+
+
+SPIR-V is not generated for failed compile or link
diff --git a/Test/baseResults/enhanced.2.frag.out b/Test/baseResults/enhanced.2.frag.out
new file mode 100644
index 0000000..a7e48de
--- /dev/null
+++ b/Test/baseResults/enhanced.2.frag.out
@@ -0,0 +1,6 @@
+enhanced.2.frag
+ERROR: enhanced.2.frag:5: ' vec3 constructor' : too many arguments 
+ERROR: 1 compilation errors.  No code generated.
+
+
+SPIR-V is not generated for failed compile or link
diff --git a/Test/baseResults/enhanced.3.link.out b/Test/baseResults/enhanced.3.link.out
new file mode 100644
index 0000000..c0e6a20
--- /dev/null
+++ b/Test/baseResults/enhanced.3.link.out
@@ -0,0 +1,8 @@
+enhanced.3.vert
+enhanced.3.frag
+ERROR: Linking vertex and fragment stages: Member names and types must match:
+    Block: VS_OUT
+        vertex stage: " vec2 TexCoords"
+        fragment stage: " vec2 foobar"
+
+SPIR-V is not generated for failed compile or link
diff --git a/Test/baseResults/enhanced.4.link.out b/Test/baseResults/enhanced.4.link.out
new file mode 100644
index 0000000..2c0acf4
--- /dev/null
+++ b/Test/baseResults/enhanced.4.link.out
@@ -0,0 +1,7 @@
+enhanced.4.vert
+enhanced.4.frag
+ERROR: Linking vertex and fragment stages: Layout location qualifier must match:
+    vertex stage: Block: VS_OUT Instance: vs_out: "layout( location=0) out"
+    fragment stage: Block: VS_OUT Instance: fs_in: "layout( location=1) in"
+
+SPIR-V is not generated for failed compile or link
diff --git a/Test/baseResults/enhanced.5.link.out b/Test/baseResults/enhanced.5.link.out
new file mode 100644
index 0000000..929cfce
--- /dev/null
+++ b/Test/baseResults/enhanced.5.link.out
@@ -0,0 +1,8 @@
+enhanced.5.vert
+enhanced.5.frag
+ERROR: Linking vertex and fragment stages: Member names and types must match:
+    Block: VS_OUT
+        vertex stage: " vec2 TexCoords"
+        fragment stage: " vec3 TexCoords"
+
+SPIR-V is not generated for failed compile or link
diff --git a/Test/baseResults/enhanced.6.link.out b/Test/baseResults/enhanced.6.link.out
new file mode 100644
index 0000000..9962628
--- /dev/null
+++ b/Test/baseResults/enhanced.6.link.out
@@ -0,0 +1,7 @@
+enhanced.6.vert
+enhanced.6.frag
+ERROR: Linking vertex and fragment stages: Array sizes must be compatible:
+    vertex stage: " VS_OUT{ vec2 TexCoords} vs_out[2]"
+    fragment stage: " VS_OUT{ vec2 TexCoords} fs_in[1]"
+
+SPIR-V is not generated for failed compile or link
diff --git a/Test/baseResults/enhanced.7.link.out b/Test/baseResults/enhanced.7.link.out
new file mode 100644
index 0000000..a6333be
--- /dev/null
+++ b/Test/baseResults/enhanced.7.link.out
@@ -0,0 +1,7 @@
+enhanced.7.vert
+enhanced.7.frag
+ERROR: Linking vertex and fragment stages: vertex block member has no corresponding member in fragment block:
+    vertex stage: Block: Vertex, Member: ii
+    fragment stage: Block: Vertex, Member: n/a 
+
+SPIR-V is not generated for failed compile or link
diff --git a/Test/baseResults/floatBitsToInt.vert.out b/Test/baseResults/floatBitsToInt.vert.out
new file mode 100644
index 0000000..6d5185c
--- /dev/null
+++ b/Test/baseResults/floatBitsToInt.vert.out
@@ -0,0 +1,217 @@
+floatBitsToInt.vert
+WARNING: 0:2: '#extension' : extension is only partially supported: GL_ARB_gpu_shader5
+
+Shader version: 150
+Requested GL_ARB_gpu_shader5
+0:? Sequence
+0:6  Function Definition: main( ( global void)
+0:6    Function Parameters: 
+0:8    Sequence
+0:8      move second child to first child ( temp 4-component vector of float)
+0:8        'result' ( smooth out 4-component vector of float)
+0:8        Constant:
+0:8          1.000000
+0:8          1.000000
+0:8          1.000000
+0:8          1.000000
+0:9      Sequence
+0:9        move second child to first child ( temp int)
+0:9          'ret_val' ( temp int)
+0:9          floatBitsToInt ( global int)
+0:9            'value' ( uniform float)
+0:10      Test condition and select ( temp void)
+0:10        Condition
+0:10        Compare Not Equal ( temp bool)
+0:10          'expected_value' ( uniform int)
+0:10          'ret_val' ( temp int)
+0:10        true case
+0:10        Sequence
+0:10          move second child to first child ( temp 4-component vector of float)
+0:10            'result' ( smooth out 4-component vector of float)
+0:10            Constant:
+0:10              0.000000
+0:10              0.000000
+0:10              0.000000
+0:10              0.000000
+0:12      switch
+0:12      condition
+0:12        'gl_VertexID' ( gl_VertexId int VertexId)
+0:12      body
+0:12        Sequence
+0:13          case:  with expression
+0:13            Constant:
+0:13              0 (const int)
+0:?           Sequence
+0:13            move second child to first child ( temp 4-component vector of float)
+0:13              gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:13                'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position,  gl_PointSize float PointSize gl_PointSize,  out unsized 1-element array of float ClipDistance gl_ClipDistance})
+0:13                Constant:
+0:13                  0 (const uint)
+0:13              Constant:
+0:13                -1.000000
+0:13                1.000000
+0:13                0.000000
+0:13                1.000000
+0:13            Branch: Break
+0:14          case:  with expression
+0:14            Constant:
+0:14              1 (const int)
+0:?           Sequence
+0:14            move second child to first child ( temp 4-component vector of float)
+0:14              gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:14                'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position,  gl_PointSize float PointSize gl_PointSize,  out unsized 1-element array of float ClipDistance gl_ClipDistance})
+0:14                Constant:
+0:14                  0 (const uint)
+0:14              Constant:
+0:14                1.000000
+0:14                1.000000
+0:14                0.000000
+0:14                1.000000
+0:14            Branch: Break
+0:15          case:  with expression
+0:15            Constant:
+0:15              2 (const int)
+0:?           Sequence
+0:15            move second child to first child ( temp 4-component vector of float)
+0:15              gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:15                'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position,  gl_PointSize float PointSize gl_PointSize,  out unsized 1-element array of float ClipDistance gl_ClipDistance})
+0:15                Constant:
+0:15                  0 (const uint)
+0:15              Constant:
+0:15                -1.000000
+0:15                -1.000000
+0:15                0.000000
+0:15                1.000000
+0:15            Branch: Break
+0:16          case:  with expression
+0:16            Constant:
+0:16              3 (const int)
+0:?           Sequence
+0:16            move second child to first child ( temp 4-component vector of float)
+0:16              gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:16                'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position,  gl_PointSize float PointSize gl_PointSize,  out unsized 1-element array of float ClipDistance gl_ClipDistance})
+0:16                Constant:
+0:16                  0 (const uint)
+0:16              Constant:
+0:16                1.000000
+0:16                -1.000000
+0:16                0.000000
+0:16                1.000000
+0:16            Branch: Break
+0:?   Linker Objects
+0:?     'expected_value' ( uniform int)
+0:?     'value' ( uniform float)
+0:?     'result' ( smooth out 4-component vector of float)
+0:?     'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position,  gl_PointSize float PointSize gl_PointSize,  out unsized 1-element array of float ClipDistance gl_ClipDistance})
+0:?     'gl_VertexID' ( gl_VertexId int VertexId)
+0:?     'gl_InstanceID' ( gl_InstanceId int InstanceId)
+
+
+Linked vertex stage:
+
+
+Shader version: 150
+Requested GL_ARB_gpu_shader5
+0:? Sequence
+0:6  Function Definition: main( ( global void)
+0:6    Function Parameters: 
+0:8    Sequence
+0:8      move second child to first child ( temp 4-component vector of float)
+0:8        'result' ( smooth out 4-component vector of float)
+0:8        Constant:
+0:8          1.000000
+0:8          1.000000
+0:8          1.000000
+0:8          1.000000
+0:9      Sequence
+0:9        move second child to first child ( temp int)
+0:9          'ret_val' ( temp int)
+0:9          floatBitsToInt ( global int)
+0:9            'value' ( uniform float)
+0:10      Test condition and select ( temp void)
+0:10        Condition
+0:10        Compare Not Equal ( temp bool)
+0:10          'expected_value' ( uniform int)
+0:10          'ret_val' ( temp int)
+0:10        true case
+0:10        Sequence
+0:10          move second child to first child ( temp 4-component vector of float)
+0:10            'result' ( smooth out 4-component vector of float)
+0:10            Constant:
+0:10              0.000000
+0:10              0.000000
+0:10              0.000000
+0:10              0.000000
+0:12      switch
+0:12      condition
+0:12        'gl_VertexID' ( gl_VertexId int VertexId)
+0:12      body
+0:12        Sequence
+0:13          case:  with expression
+0:13            Constant:
+0:13              0 (const int)
+0:?           Sequence
+0:13            move second child to first child ( temp 4-component vector of float)
+0:13              gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:13                'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position,  gl_PointSize float PointSize gl_PointSize,  out 1-element array of float ClipDistance gl_ClipDistance})
+0:13                Constant:
+0:13                  0 (const uint)
+0:13              Constant:
+0:13                -1.000000
+0:13                1.000000
+0:13                0.000000
+0:13                1.000000
+0:13            Branch: Break
+0:14          case:  with expression
+0:14            Constant:
+0:14              1 (const int)
+0:?           Sequence
+0:14            move second child to first child ( temp 4-component vector of float)
+0:14              gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:14                'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position,  gl_PointSize float PointSize gl_PointSize,  out 1-element array of float ClipDistance gl_ClipDistance})
+0:14                Constant:
+0:14                  0 (const uint)
+0:14              Constant:
+0:14                1.000000
+0:14                1.000000
+0:14                0.000000
+0:14                1.000000
+0:14            Branch: Break
+0:15          case:  with expression
+0:15            Constant:
+0:15              2 (const int)
+0:?           Sequence
+0:15            move second child to first child ( temp 4-component vector of float)
+0:15              gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:15                'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position,  gl_PointSize float PointSize gl_PointSize,  out 1-element array of float ClipDistance gl_ClipDistance})
+0:15                Constant:
+0:15                  0 (const uint)
+0:15              Constant:
+0:15                -1.000000
+0:15                -1.000000
+0:15                0.000000
+0:15                1.000000
+0:15            Branch: Break
+0:16          case:  with expression
+0:16            Constant:
+0:16              3 (const int)
+0:?           Sequence
+0:16            move second child to first child ( temp 4-component vector of float)
+0:16              gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:16                'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position,  gl_PointSize float PointSize gl_PointSize,  out 1-element array of float ClipDistance gl_ClipDistance})
+0:16                Constant:
+0:16                  0 (const uint)
+0:16              Constant:
+0:16                1.000000
+0:16                -1.000000
+0:16                0.000000
+0:16                1.000000
+0:16            Branch: Break
+0:?   Linker Objects
+0:?     'expected_value' ( uniform int)
+0:?     'value' ( uniform float)
+0:?     'result' ( smooth out 4-component vector of float)
+0:?     'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position,  gl_PointSize float PointSize gl_PointSize,  out 1-element array of float ClipDistance gl_ClipDistance})
+0:?     'gl_VertexID' ( gl_VertexId int VertexId)
+0:?     'gl_InstanceID' ( gl_InstanceId int InstanceId)
+
diff --git a/Test/baseResults/gl_FragCoord.frag.out b/Test/baseResults/gl_FragCoord.frag.out
new file mode 100644
index 0000000..da9e8dc
--- /dev/null
+++ b/Test/baseResults/gl_FragCoord.frag.out
@@ -0,0 +1,269 @@
+gl_FragCoord.frag
+Shader version: 150
+Requested GL_ARB_explicit_attrib_location
+gl_FragCoord pixel center is integer
+gl_FragCoord origin is upper left
+0:? Sequence
+0:9  Sequence
+0:9    move second child to first child ( temp float)
+0:9      'myGlobalVar' ( global float)
+0:9      direct index ( temp float)
+0:9        'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:9        Constant:
+0:9          0 (const int)
+0:16  Function Definition: main( ( global void)
+0:16    Function Parameters: 
+0:17    Sequence
+0:17      move second child to first child ( temp 4-component vector of float)
+0:17        'myColor' (layout( location=0) out 4-component vector of float)
+0:17        Constant:
+0:17          0.200000
+0:17          0.200000
+0:17          0.200000
+0:17          0.200000
+0:18      Test condition and select ( temp void)
+0:18        Condition
+0:18        Compare Greater Than or Equal ( temp bool)
+0:18          direct index ( temp float)
+0:18            'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:18            Constant:
+0:18              1 (const int)
+0:18          Constant:
+0:18            10.000000
+0:18        true case
+0:19        Sequence
+0:19          move second child to first child ( temp float)
+0:19            direct index ( temp float)
+0:19              'myColor' (layout( location=0) out 4-component vector of float)
+0:19              Constant:
+0:19                2 (const int)
+0:19            Constant:
+0:19              0.800000
+0:21      Test condition and select ( temp void)
+0:21        Condition
+0:21        Compare Equal ( temp bool)
+0:21          direct index ( temp float)
+0:21            'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:21            Constant:
+0:21              1 (const int)
+0:21          trunc ( global float)
+0:21            direct index ( temp float)
+0:21              'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:21              Constant:
+0:21                1 (const int)
+0:21        true case
+0:22        Sequence
+0:22          move second child to first child ( temp float)
+0:22            direct index ( temp float)
+0:22              'myColor' (layout( location=0) out 4-component vector of float)
+0:22              Constant:
+0:22                1 (const int)
+0:22            Constant:
+0:22              0.800000
+0:24      Test condition and select ( temp void)
+0:24        Condition
+0:24        Compare Equal ( temp bool)
+0:24          direct index ( temp float)
+0:24            'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:24            Constant:
+0:24              0 (const int)
+0:24          trunc ( global float)
+0:24            direct index ( temp float)
+0:24              'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:24              Constant:
+0:24                0 (const int)
+0:24        true case
+0:25        Sequence
+0:25          move second child to first child ( temp float)
+0:25            direct index ( temp float)
+0:25              'myColor' (layout( location=0) out 4-component vector of float)
+0:25              Constant:
+0:25                0 (const int)
+0:25            Constant:
+0:25              0.800000
+0:28      Sequence
+0:28        move second child to first child ( temp 4-component vector of float)
+0:28          'diff' ( temp 4-component vector of float)
+0:28          subtract ( temp 4-component vector of float)
+0:28            'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:28            'i' ( smooth in 4-component vector of float)
+0:29      Test condition and select ( temp void)
+0:29        Condition
+0:29        Compare Greater Than ( temp bool)
+0:29          Absolute value ( global float)
+0:29            direct index ( temp float)
+0:29              'diff' ( temp 4-component vector of float)
+0:29              Constant:
+0:29                2 (const int)
+0:29          Constant:
+0:29            0.001000
+0:29        true case
+0:29        move second child to first child ( temp float)
+0:29          direct index ( temp float)
+0:29            'myColor' (layout( location=0) out 4-component vector of float)
+0:29            Constant:
+0:29              2 (const int)
+0:29          Constant:
+0:29            0.500000
+0:30      Test condition and select ( temp void)
+0:30        Condition
+0:30        Compare Greater Than ( temp bool)
+0:30          Absolute value ( global float)
+0:30            direct index ( temp float)
+0:30              'diff' ( temp 4-component vector of float)
+0:30              Constant:
+0:30                3 (const int)
+0:30          Constant:
+0:30            0.001000
+0:30        true case
+0:30        move second child to first child ( temp float)
+0:30          direct index ( temp float)
+0:30            'myColor' (layout( location=0) out 4-component vector of float)
+0:30            Constant:
+0:30              3 (const int)
+0:30          Constant:
+0:30            0.500000
+0:?   Linker Objects
+0:?     'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:?     'myGlobalVar' ( global float)
+0:?     'i' ( smooth in 4-component vector of float)
+0:?     'myColor' (layout( location=0) out 4-component vector of float)
+0:?     'eps' ( const float)
+0:?       0.001000
+
+
+Linked fragment stage:
+
+
+Shader version: 150
+Requested GL_ARB_explicit_attrib_location
+gl_FragCoord pixel center is integer
+gl_FragCoord origin is upper left
+0:? Sequence
+0:9  Sequence
+0:9    move second child to first child ( temp float)
+0:9      'myGlobalVar' ( global float)
+0:9      direct index ( temp float)
+0:9        'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:9        Constant:
+0:9          0 (const int)
+0:16  Function Definition: main( ( global void)
+0:16    Function Parameters: 
+0:17    Sequence
+0:17      move second child to first child ( temp 4-component vector of float)
+0:17        'myColor' (layout( location=0) out 4-component vector of float)
+0:17        Constant:
+0:17          0.200000
+0:17          0.200000
+0:17          0.200000
+0:17          0.200000
+0:18      Test condition and select ( temp void)
+0:18        Condition
+0:18        Compare Greater Than or Equal ( temp bool)
+0:18          direct index ( temp float)
+0:18            'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:18            Constant:
+0:18              1 (const int)
+0:18          Constant:
+0:18            10.000000
+0:18        true case
+0:19        Sequence
+0:19          move second child to first child ( temp float)
+0:19            direct index ( temp float)
+0:19              'myColor' (layout( location=0) out 4-component vector of float)
+0:19              Constant:
+0:19                2 (const int)
+0:19            Constant:
+0:19              0.800000
+0:21      Test condition and select ( temp void)
+0:21        Condition
+0:21        Compare Equal ( temp bool)
+0:21          direct index ( temp float)
+0:21            'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:21            Constant:
+0:21              1 (const int)
+0:21          trunc ( global float)
+0:21            direct index ( temp float)
+0:21              'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:21              Constant:
+0:21                1 (const int)
+0:21        true case
+0:22        Sequence
+0:22          move second child to first child ( temp float)
+0:22            direct index ( temp float)
+0:22              'myColor' (layout( location=0) out 4-component vector of float)
+0:22              Constant:
+0:22                1 (const int)
+0:22            Constant:
+0:22              0.800000
+0:24      Test condition and select ( temp void)
+0:24        Condition
+0:24        Compare Equal ( temp bool)
+0:24          direct index ( temp float)
+0:24            'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:24            Constant:
+0:24              0 (const int)
+0:24          trunc ( global float)
+0:24            direct index ( temp float)
+0:24              'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:24              Constant:
+0:24                0 (const int)
+0:24        true case
+0:25        Sequence
+0:25          move second child to first child ( temp float)
+0:25            direct index ( temp float)
+0:25              'myColor' (layout( location=0) out 4-component vector of float)
+0:25              Constant:
+0:25                0 (const int)
+0:25            Constant:
+0:25              0.800000
+0:28      Sequence
+0:28        move second child to first child ( temp 4-component vector of float)
+0:28          'diff' ( temp 4-component vector of float)
+0:28          subtract ( temp 4-component vector of float)
+0:28            'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:28            'i' ( smooth in 4-component vector of float)
+0:29      Test condition and select ( temp void)
+0:29        Condition
+0:29        Compare Greater Than ( temp bool)
+0:29          Absolute value ( global float)
+0:29            direct index ( temp float)
+0:29              'diff' ( temp 4-component vector of float)
+0:29              Constant:
+0:29                2 (const int)
+0:29          Constant:
+0:29            0.001000
+0:29        true case
+0:29        move second child to first child ( temp float)
+0:29          direct index ( temp float)
+0:29            'myColor' (layout( location=0) out 4-component vector of float)
+0:29            Constant:
+0:29              2 (const int)
+0:29          Constant:
+0:29            0.500000
+0:30      Test condition and select ( temp void)
+0:30        Condition
+0:30        Compare Greater Than ( temp bool)
+0:30          Absolute value ( global float)
+0:30            direct index ( temp float)
+0:30              'diff' ( temp 4-component vector of float)
+0:30              Constant:
+0:30                3 (const int)
+0:30          Constant:
+0:30            0.001000
+0:30        true case
+0:30        move second child to first child ( temp float)
+0:30          direct index ( temp float)
+0:30            'myColor' (layout( location=0) out 4-component vector of float)
+0:30            Constant:
+0:30              3 (const int)
+0:30          Constant:
+0:30            0.500000
+0:?   Linker Objects
+0:?     'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:?     'myGlobalVar' ( global float)
+0:?     'i' ( smooth in 4-component vector of float)
+0:?     'myColor' (layout( location=0) out 4-component vector of float)
+0:?     'eps' ( const float)
+0:?       0.001000
+
diff --git a/Test/baseResults/glsl.460.subgroupEXT.mesh.out b/Test/baseResults/glsl.460.subgroupEXT.mesh.out
new file mode 100644
index 0000000..8d45106
--- /dev/null
+++ b/Test/baseResults/glsl.460.subgroupEXT.mesh.out
@@ -0,0 +1,1039 @@
+glsl.460.subgroupEXT.mesh
+ERROR: 0:6: 'gl_SubgroupSize' : required extension not requested: GL_KHR_shader_subgroup_basic
+ERROR: 0:7: 'gl_SubgroupInvocationID' : required extension not requested: GL_KHR_shader_subgroup_basic
+ERROR: 0:8: 'subgroupBarrier' : required extension not requested: GL_KHR_shader_subgroup_basic
+ERROR: 0:9: 'subgroupMemoryBarrier' : required extension not requested: GL_KHR_shader_subgroup_basic
+ERROR: 0:10: 'subgroupMemoryBarrierBuffer' : required extension not requested: GL_KHR_shader_subgroup_basic
+ERROR: 0:11: 'subgroupMemoryBarrierImage' : required extension not requested: GL_KHR_shader_subgroup_basic
+ERROR: 0:12: 'subgroupElect' : required extension not requested: GL_KHR_shader_subgroup_basic
+ERROR: 0:13: 'gl_NumSubgroups' : required extension not requested: GL_KHR_shader_subgroup_basic
+ERROR: 0:14: 'gl_SubgroupID' : required extension not requested: GL_KHR_shader_subgroup_basic
+ERROR: 0:15: 'subgroupMemoryBarrierShared' : required extension not requested: GL_KHR_shader_subgroup_basic
+ERROR: 0:17: 'subgroupAll' : required extension not requested: GL_KHR_shader_subgroup_vote
+ERROR: 0:18: 'subgroupAny' : required extension not requested: GL_KHR_shader_subgroup_vote
+ERROR: 0:19: 'subgroupAllEqual' : required extension not requested: GL_KHR_shader_subgroup_vote
+ERROR: 0:21: 'gl_SubgroupEqMask' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:22: 'gl_SubgroupGeMask' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:23: 'gl_SubgroupGtMask' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:24: 'gl_SubgroupLeMask' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:25: 'gl_SubgroupLtMask' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:26: 'subgroupBroadcast' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:27: 'subgroupBroadcastFirst' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:28: 'subgroupBallot' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:29: 'subgroupInverseBallot' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:30: 'subgroupBallotBitExtract' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:31: 'subgroupBallotBitCount' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:32: 'subgroupBallotInclusiveBitCount' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:33: 'subgroupBallotExclusiveBitCount' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:34: 'subgroupBallotFindLSB' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:35: 'subgroupBallotFindMSB' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:37: 'subgroupShuffle' : required extension not requested: GL_KHR_shader_subgroup_shuffle
+ERROR: 0:38: 'subgroupShuffleXor' : required extension not requested: GL_KHR_shader_subgroup_shuffle
+ERROR: 0:39: 'subgroupShuffleUp' : required extension not requested: GL_KHR_shader_subgroup_shuffle_relative
+ERROR: 0:40: 'subgroupShuffleDown' : required extension not requested: GL_KHR_shader_subgroup_shuffle_relative
+ERROR: 0:42: 'subgroupAdd' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:43: 'subgroupMul' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:44: 'subgroupMin' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:45: 'subgroupMax' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:46: 'subgroupAnd' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:47: 'subgroupOr' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:48: 'subgroupXor' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:49: 'subgroupInclusiveAdd' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:50: 'subgroupInclusiveMul' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:51: 'subgroupInclusiveMin' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:52: 'subgroupInclusiveMax' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:53: 'subgroupInclusiveAnd' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:54: 'subgroupInclusiveOr' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:55: 'subgroupInclusiveXor' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:56: 'subgroupExclusiveAdd' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:57: 'subgroupExclusiveMul' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:58: 'subgroupExclusiveMin' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:59: 'subgroupExclusiveMax' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:60: 'subgroupExclusiveAnd' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:61: 'subgroupExclusiveOr' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:62: 'subgroupExclusiveXor' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:64: 'subgroupClusteredAdd' : required extension not requested: GL_KHR_shader_subgroup_clustered
+ERROR: 0:65: 'subgroupClusteredMul' : required extension not requested: GL_KHR_shader_subgroup_clustered
+ERROR: 0:66: 'subgroupClusteredMin' : required extension not requested: GL_KHR_shader_subgroup_clustered
+ERROR: 0:67: 'subgroupClusteredMax' : required extension not requested: GL_KHR_shader_subgroup_clustered
+ERROR: 0:68: 'subgroupClusteredAnd' : required extension not requested: GL_KHR_shader_subgroup_clustered
+ERROR: 0:69: 'subgroupClusteredOr' : required extension not requested: GL_KHR_shader_subgroup_clustered
+ERROR: 0:70: 'subgroupClusteredXor' : required extension not requested: GL_KHR_shader_subgroup_clustered
+ERROR: 0:72: 'subgroupQuadBroadcast' : required extension not requested: GL_KHR_shader_subgroup_quad
+ERROR: 0:73: 'subgroupQuadSwapHorizontal' : required extension not requested: GL_KHR_shader_subgroup_quad
+ERROR: 0:74: 'subgroupQuadSwapVertical' : required extension not requested: GL_KHR_shader_subgroup_quad
+ERROR: 0:75: 'subgroupQuadSwapDiagonal' : required extension not requested: GL_KHR_shader_subgroup_quad
+ERROR: 64 compilation errors.  No code generated.
+
+
+Shader version: 460
+Requested GL_EXT_mesh_shader
+Requested GL_KHR_shader_subgroup_arithmetic
+Requested GL_KHR_shader_subgroup_ballot
+Requested GL_KHR_shader_subgroup_basic
+Requested GL_KHR_shader_subgroup_clustered
+Requested GL_KHR_shader_subgroup_quad
+Requested GL_KHR_shader_subgroup_shuffle
+Requested GL_KHR_shader_subgroup_shuffle_relative
+Requested GL_KHR_shader_subgroup_vote
+max_vertices = 81
+max_primitives = 32
+output primitive = triangles
+local_size = (32, 1, 1)
+ERROR: node is still EOpNull!
+0:3  Function Definition: undeclared_errors(vf4; ( global 4-component vector of float)
+0:3    Function Parameters: 
+0:3      'f4' ( in 4-component vector of float)
+0:?     Sequence
+0:6      'gl_SubgroupSize' ( in uint SubgroupSize)
+0:7      'gl_SubgroupInvocationID' ( in uint SubgroupInvocationID)
+0:8      subgroupBarrier ( global void)
+0:9      subgroupMemoryBarrier ( global void)
+0:10      subgroupMemoryBarrierBuffer ( global void)
+0:11      subgroupMemoryBarrierImage ( global void)
+0:12      subgroupElect ( global bool)
+0:13      'gl_NumSubgroups' ( in uint NumSubgroups)
+0:14      'gl_SubgroupID' ( in uint SubgroupID)
+0:15      subgroupMemoryBarrierShared ( global void)
+0:17      subgroupAll ( global bool)
+0:17        Constant:
+0:17          true (const bool)
+0:18      subgroupAny ( global bool)
+0:18        Constant:
+0:18          false (const bool)
+0:19      subgroupAllEqual ( global bool)
+0:19        'f4' ( in 4-component vector of float)
+0:21      'gl_SubgroupEqMask' ( in 4-component vector of uint SubgroupEqMask)
+0:22      'gl_SubgroupGeMask' ( in 4-component vector of uint SubgroupGeMask)
+0:23      'gl_SubgroupGtMask' ( in 4-component vector of uint SubgroupGtMask)
+0:24      'gl_SubgroupLeMask' ( in 4-component vector of uint SubgroupLeMask)
+0:25      'gl_SubgroupLtMask' ( in 4-component vector of uint SubgroupLtMask)
+0:26      subgroupBroadcast ( global 4-component vector of float)
+0:26        'f4' ( in 4-component vector of float)
+0:26        Constant:
+0:26          0 (const uint)
+0:27      subgroupBroadcastFirst ( global 4-component vector of float)
+0:27        'f4' ( in 4-component vector of float)
+0:28      Sequence
+0:28        move second child to first child ( temp 4-component vector of uint)
+0:28          'ballot' ( temp 4-component vector of uint)
+0:28          subgroupBallot ( global 4-component vector of uint)
+0:28            Constant:
+0:28              false (const bool)
+0:29      subgroupInverseBallot ( global bool)
+0:29        Constant:
+0:29          1 (const uint)
+0:29          1 (const uint)
+0:29          1 (const uint)
+0:29          1 (const uint)
+0:30      subgroupBallotBitExtract ( global bool)
+0:30        'ballot' ( temp 4-component vector of uint)
+0:30        Constant:
+0:30          0 (const uint)
+0:31      subgroupBallotBitCount ( global uint)
+0:31        'ballot' ( temp 4-component vector of uint)
+0:32      subgroupBallotInclusiveBitCount ( global uint)
+0:32        'ballot' ( temp 4-component vector of uint)
+0:33      subgroupBallotExclusiveBitCount ( global uint)
+0:33        'ballot' ( temp 4-component vector of uint)
+0:34      subgroupBallotFindLSB ( global uint)
+0:34        'ballot' ( temp 4-component vector of uint)
+0:35      subgroupBallotFindMSB ( global uint)
+0:35        'ballot' ( temp 4-component vector of uint)
+0:37      subgroupShuffle ( global 4-component vector of float)
+0:37        'f4' ( in 4-component vector of float)
+0:37        Constant:
+0:37          0 (const uint)
+0:38      subgroupShuffleXor ( global 4-component vector of float)
+0:38        'f4' ( in 4-component vector of float)
+0:38        Constant:
+0:38          1 (const uint)
+0:39      subgroupShuffleUp ( global 4-component vector of float)
+0:39        'f4' ( in 4-component vector of float)
+0:39        Constant:
+0:39          1 (const uint)
+0:40      subgroupShuffleDown ( global 4-component vector of float)
+0:40        'f4' ( in 4-component vector of float)
+0:40        Constant:
+0:40          1 (const uint)
+0:42      move second child to first child ( temp 4-component vector of float)
+0:42        'result' ( temp 4-component vector of float)
+0:42        subgroupAdd ( global 4-component vector of float)
+0:42          'f4' ( in 4-component vector of float)
+0:43      subgroupMul ( global 4-component vector of float)
+0:43        'f4' ( in 4-component vector of float)
+0:44      subgroupMin ( global 4-component vector of float)
+0:44        'f4' ( in 4-component vector of float)
+0:45      subgroupMax ( global 4-component vector of float)
+0:45        'f4' ( in 4-component vector of float)
+0:46      subgroupAnd ( global 4-component vector of uint)
+0:46        'ballot' ( temp 4-component vector of uint)
+0:47      subgroupOr ( global 4-component vector of uint)
+0:47        'ballot' ( temp 4-component vector of uint)
+0:48      subgroupXor ( global 4-component vector of uint)
+0:48        'ballot' ( temp 4-component vector of uint)
+0:49      subgroupInclusiveAdd ( global 4-component vector of float)
+0:49        'f4' ( in 4-component vector of float)
+0:50      subgroupInclusiveMul ( global 4-component vector of float)
+0:50        'f4' ( in 4-component vector of float)
+0:51      subgroupInclusiveMin ( global 4-component vector of float)
+0:51        'f4' ( in 4-component vector of float)
+0:52      subgroupInclusiveMax ( global 4-component vector of float)
+0:52        'f4' ( in 4-component vector of float)
+0:53      subgroupInclusiveAnd ( global 4-component vector of uint)
+0:53        'ballot' ( temp 4-component vector of uint)
+0:54      subgroupInclusiveOr ( global 4-component vector of uint)
+0:54        'ballot' ( temp 4-component vector of uint)
+0:55      subgroupInclusiveXor ( global 4-component vector of uint)
+0:55        'ballot' ( temp 4-component vector of uint)
+0:56      subgroupExclusiveAdd ( global 4-component vector of float)
+0:56        'f4' ( in 4-component vector of float)
+0:57      subgroupExclusiveMul ( global 4-component vector of float)
+0:57        'f4' ( in 4-component vector of float)
+0:58      subgroupExclusiveMin ( global 4-component vector of float)
+0:58        'f4' ( in 4-component vector of float)
+0:59      subgroupExclusiveMax ( global 4-component vector of float)
+0:59        'f4' ( in 4-component vector of float)
+0:60      subgroupExclusiveAnd ( global 4-component vector of uint)
+0:60        'ballot' ( temp 4-component vector of uint)
+0:61      subgroupExclusiveOr ( global 4-component vector of uint)
+0:61        'ballot' ( temp 4-component vector of uint)
+0:62      subgroupExclusiveXor ( global 4-component vector of uint)
+0:62        'ballot' ( temp 4-component vector of uint)
+0:64      subgroupClusteredAdd ( global 4-component vector of float)
+0:64        'f4' ( in 4-component vector of float)
+0:64        Constant:
+0:64          2 (const uint)
+0:65      subgroupClusteredMul ( global 4-component vector of float)
+0:65        'f4' ( in 4-component vector of float)
+0:65        Constant:
+0:65          2 (const uint)
+0:66      subgroupClusteredMin ( global 4-component vector of float)
+0:66        'f4' ( in 4-component vector of float)
+0:66        Constant:
+0:66          2 (const uint)
+0:67      subgroupClusteredMax ( global 4-component vector of float)
+0:67        'f4' ( in 4-component vector of float)
+0:67        Constant:
+0:67          2 (const uint)
+0:68      subgroupClusteredAnd ( global 4-component vector of uint)
+0:68        'ballot' ( temp 4-component vector of uint)
+0:68        Constant:
+0:68          2 (const uint)
+0:69      subgroupClusteredOr ( global 4-component vector of uint)
+0:69        'ballot' ( temp 4-component vector of uint)
+0:69        Constant:
+0:69          2 (const uint)
+0:70      subgroupClusteredXor ( global 4-component vector of uint)
+0:70        'ballot' ( temp 4-component vector of uint)
+0:70        Constant:
+0:70          2 (const uint)
+0:72      subgroupQuadBroadcast ( global 4-component vector of float)
+0:72        'f4' ( in 4-component vector of float)
+0:72        Constant:
+0:72          0 (const uint)
+0:73      subgroupQuadSwapHorizontal ( global 4-component vector of float)
+0:73        'f4' ( in 4-component vector of float)
+0:74      subgroupQuadSwapVertical ( global 4-component vector of float)
+0:74        'f4' ( in 4-component vector of float)
+0:75      subgroupQuadSwapDiagonal ( global 4-component vector of float)
+0:75        'f4' ( in 4-component vector of float)
+0:77      Branch: Return with expression
+0:77        'result' ( temp 4-component vector of float)
+0:97  Function Definition: main( ( global void)
+0:97    Function Parameters: 
+0:99    Sequence
+0:99      Sequence
+0:99        move second child to first child ( temp uint)
+0:99          'iid' ( temp uint)