diff --git a/hw/amdgpu/bridge/src/bridge.cpp b/hw/amdgpu/bridge/src/bridge.cpp
index 0d38f9410..63bb1fd16 100644
--- a/hw/amdgpu/bridge/src/bridge.cpp
+++ b/hw/amdgpu/bridge/src/bridge.cpp
@@ -37,8 +37,8 @@ amdgpu::bridge::createShmCommandBuffer(const char *name) {
 
   gShmFd = fd;
   auto result = new (memory) amdgpu::bridge::BridgeHeader();
-  result->size = (kShmSize - sizeof(amdgpu::bridge::BridgeHeader)) /
-                 sizeof(std::uint64_t);
+  result->size =
+      (kShmSize - sizeof(amdgpu::bridge::BridgeHeader)) / sizeof(std::uint64_t);
   return result;
 }
 
diff --git a/hw/amdgpu/device/include/amdgpu/device/pm4.hpp b/hw/amdgpu/device/include/amdgpu/device/pm4.hpp
index f40cb8672..6d9cf259d 100644
--- a/hw/amdgpu/device/include/amdgpu/device/pm4.hpp
+++ b/hw/amdgpu/device/include/amdgpu/device/pm4.hpp
@@ -98,5 +98,4 @@ enum PM4Opcodes {
 };
 
 const char *pm4OpcodeToString(int opcode);
-} // namespace amdgpu::device
-
+} // namespace amdgpu
diff --git a/hw/amdgpu/device/include/amdgpu/device/tiler.hpp b/hw/amdgpu/device/include/amdgpu/device/tiler.hpp
index aab34faac..cecb767a4 100644
--- a/hw/amdgpu/device/include/amdgpu/device/tiler.hpp
+++ b/hw/amdgpu/device/include/amdgpu/device/tiler.hpp
@@ -313,7 +313,8 @@ struct Tiler1d {
     m_bitsPerElement = 128;// getBitsPerElement(texture->dfmt);
     m_microTileMode = Gnm::MicroTileMode::kMicroTileModeThin;
     m_tileThickness = (m_arrayMode == Gnm::kArrayMode1dTiledThick) ? 4 : 1;
-    m_tileBytes     = (kMicroTileWidth * kMicroTileHeight * m_tileThickness * m_bitsPerElement + 7) / 8;
+    m_tileBytes     = (kMicroTileWidth * kMicroTileHeight * m_tileThickness *
+    m_bitsPerElement + 7) / 8;
 
     auto width = texture->width + 1;
     auto height = texture->height + 1;
@@ -326,8 +327,8 @@ struct Tiler1d {
     m_arrayMode = (Gnm::ArrayMode)2;
     m_bitsPerElement = 128;
     m_microTileMode = (Gnm::MicroTileMode)1;
-    m_tileThickness= 1;
-    m_tileBytes= 1024;
+    m_tileThickness = 1;
+    m_tileBytes = 1024;
     m_tilesPerRow = 16;
     m_tilesPerSlice = 256;
   }
diff --git a/hw/amdgpu/include/amdgpu/RemoteMemory.hpp b/hw/amdgpu/include/amdgpu/RemoteMemory.hpp
index cb58ef5cc..e292bc515 100644
--- a/hw/amdgpu/include/amdgpu/RemoteMemory.hpp
+++ b/hw/amdgpu/include/amdgpu/RemoteMemory.hpp
@@ -6,7 +6,8 @@ struct RemoteMemory {
   char *shmPointer;
 
   template <typename T = void> T *getPointer(std::uint64_t address) const {
-    return address ? reinterpret_cast<T *>(shmPointer + address - 0x40000) : nullptr;
+    return address ? reinterpret_cast<T *>(shmPointer + address - 0x40000)
+                   : nullptr;
   }
 };
 } // namespace amdgpu
diff --git a/hw/amdgpu/include/util/Verify.hpp b/hw/amdgpu/include/util/Verify.hpp
index 84ed86289..ba40e8231 100644
--- a/hw/amdgpu/include/util/Verify.hpp
+++ b/hw/amdgpu/include/util/Verify.hpp
@@ -7,9 +7,7 @@ class Verify {
   util::SourceLocation mLocation;
 
 public:
-  util::SourceLocation location() const {
-    return mLocation;
-  }
+  util::SourceLocation location() const { return mLocation; }
 
   Verify(util::SourceLocation location = util::SourceLocation())
       : mLocation(location) {}
diff --git a/hw/amdgpu/include/util/VerifyVulkan.hpp b/hw/amdgpu/include/util/VerifyVulkan.hpp
index 1060ce934..4665990a5 100644
--- a/hw/amdgpu/include/util/VerifyVulkan.hpp
+++ b/hw/amdgpu/include/util/VerifyVulkan.hpp
@@ -12,4 +12,3 @@ inline Verify operator<<(Verify lhs, VkResult result) {
 
   return lhs;
 }
-
diff --git a/hw/amdgpu/include/util/unreachable.hpp b/hw/amdgpu/include/util/unreachable.hpp
index 50d9facfc..64e8396d0 100644
--- a/hw/amdgpu/include/util/unreachable.hpp
+++ b/hw/amdgpu/include/util/unreachable.hpp
@@ -1,11 +1,14 @@
 #pragma once
 
 #include "SourceLocation.hpp"
-#include <cstdio>
 #include <cstdarg>
+#include <cstdio>
 
 namespace util {
-[[noreturn]] inline void unreachable_impl() { std::fflush(stdout); __builtin_trap(); }
+[[noreturn]] inline void unreachable_impl() {
+  std::fflush(stdout);
+  __builtin_trap();
+}
 
 [[noreturn]] inline void unreachable(SourceLocation location = {}) {
   std::printf("\n");
diff --git a/hw/amdgpu/lib/libspirv/include/spirv/spirv-builder.hpp b/hw/amdgpu/lib/libspirv/include/spirv/spirv-builder.hpp
index 63122000d..ae9cfc80f 100644
--- a/hw/amdgpu/lib/libspirv/include/spirv/spirv-builder.hpp
+++ b/hw/amdgpu/lib/libspirv/include/spirv/spirv-builder.hpp
@@ -71,8 +71,8 @@ struct ImageValue : Value {};
 struct SampledImageValue : Value {};
 
 template <typename T>
-  requires(std::is_base_of_v<Value, T>)
-struct ConstantValue : T {};
+requires(std::is_base_of_v<Value, T>) struct ConstantValue : T {
+};
 
 struct AnyConstantValue : Value {
   AnyConstantValue() = default;
@@ -95,28 +95,28 @@ struct AnyConstantValue : Value {
 };
 
 template <typename T>
-  requires(std::is_base_of_v<Type, T>)
-struct VectorOfType : VectorType {};
+requires(std::is_base_of_v<Type, T>) struct VectorOfType : VectorType {
+};
 
 template <typename T>
-  requires(std::is_base_of_v<Type, T>)
-struct ArrayOfType : ArrayType {};
+requires(std::is_base_of_v<Type, T>) struct ArrayOfType : ArrayType {
+};
 
 template <typename T>
-  requires(std::is_base_of_v<Type, T>)
-struct VectorOfValue : VectorValue {};
+requires(std::is_base_of_v<Type, T>) struct VectorOfValue : VectorValue {
+};
 
 template <typename T>
-  requires(std::is_base_of_v<Type, T>)
-struct ArrayOfValue : ArrayValue {};
+requires(std::is_base_of_v<Type, T>) struct ArrayOfValue : ArrayValue {
+};
 
 template <typename T>
-  requires(std::is_base_of_v<Type, T>)
-struct PointerToType : PointerType {};
+requires(std::is_base_of_v<Type, T>) struct PointerToType : PointerType {
+};
 
 template <typename T>
-  requires(std::is_base_of_v<Type, T>)
-struct PointerToValue : PointerValue {};
+requires(std::is_base_of_v<Type, T>) struct PointerToValue : PointerValue {
+};
 
 struct StructPointerValue : Value {};
 
@@ -125,45 +125,21 @@ struct VariableValue : PointerValue {};
 namespace detail {
 template <typename T> struct TypeToValueImpl;
 
-template <> struct TypeToValueImpl<Type> {
-  using type = Value;
-};
-template <> struct TypeToValueImpl<BoolType> {
-  using type = BoolValue;
-};
-template <> struct TypeToValueImpl<IntType> {
-  using type = IntValue;
-};
-template <> struct TypeToValueImpl<SIntType> {
-  using type = SIntValue;
-};
-template <> struct TypeToValueImpl<UIntType> {
-  using type = UIntValue;
-};
-template <> struct TypeToValueImpl<FloatType> {
-  using type = FloatValue;
-};
-template <> struct TypeToValueImpl<StructType> {
-  using type = StructValue;
-};
-template <> struct TypeToValueImpl<PointerType> {
-  using type = PointerValue;
-};
+template <> struct TypeToValueImpl<Type> { using type = Value; };
+template <> struct TypeToValueImpl<BoolType> { using type = BoolValue; };
+template <> struct TypeToValueImpl<IntType> { using type = IntValue; };
+template <> struct TypeToValueImpl<SIntType> { using type = SIntValue; };
+template <> struct TypeToValueImpl<UIntType> { using type = UIntValue; };
+template <> struct TypeToValueImpl<FloatType> { using type = FloatValue; };
+template <> struct TypeToValueImpl<StructType> { using type = StructValue; };
+template <> struct TypeToValueImpl<PointerType> { using type = PointerValue; };
 template <> struct TypeToValueImpl<VariableValue> {
   using type = PointerValue;
 };
-template <> struct TypeToValueImpl<VectorType> {
-  using type = VectorValue;
-};
-template <> struct TypeToValueImpl<ArrayType> {
-  using type = ArrayValue;
-};
-template <> struct TypeToValueImpl<SamplerType> {
-  using type = SamplerValue;
-};
-template <> struct TypeToValueImpl<ImageType> {
-  using type = ImageValue;
-};
+template <> struct TypeToValueImpl<VectorType> { using type = VectorValue; };
+template <> struct TypeToValueImpl<ArrayType> { using type = ArrayValue; };
+template <> struct TypeToValueImpl<SamplerType> { using type = SamplerValue; };
+template <> struct TypeToValueImpl<ImageType> { using type = ImageValue; };
 template <> struct TypeToValueImpl<SampledImageType> {
   using type = SampledImageValue;
 };
@@ -184,8 +160,7 @@ template <typename T>
 using TypeToValue = typename detail::TypeToValueImpl<T>::type;
 
 template <typename T>
-  requires(std::is_base_of_v<Type, T>)
-struct ScalarOrVectorOfValue : Value {
+requires(std::is_base_of_v<Type, T>) struct ScalarOrVectorOfValue : Value {
   ScalarOrVectorOfValue() = default;
 
   ScalarOrVectorOfValue(TypeToValue<T> scalar) { id = scalar.id; }
@@ -199,8 +174,8 @@ using ConstantInt = ConstantValue<IntValue>;
 using ConstantFloat = ConstantValue<FloatValue>;
 
 template <typename ToT, typename FromT>
-  requires(std::is_base_of_v<FromT, ToT> && std::is_base_of_v<Id, FromT>)
-ToT cast(FromT from) {
+requires(std::is_base_of_v<FromT, ToT> &&std::is_base_of_v<Id, FromT>) ToT
+    cast(FromT from) {
   ToT result;
   result.id = from.id;
   return result;
@@ -277,8 +252,7 @@ struct IdGenerator {
   std::uint32_t bounds = 1;
 
   template <typename T>
-    requires(std::is_base_of_v<Id, T>)
-  T newId() {
+  requires(std::is_base_of_v<Id, T>) T newId() {
     T result;
     result.id = bounds++;
     return result;
@@ -544,9 +518,8 @@ public:
 
   // arithmetic
   template <typename T>
-    requires(std::is_base_of_v<ScalarType, T>)
-  TypeToValue<T> createInst(spv::Op op, T resultType,
-                            std::span<const TypeToValue<T>> operands) {
+  requires(std::is_base_of_v<ScalarType, T>) TypeToValue<T> createInst(
+      spv::Op op, T resultType, std::span<const TypeToValue<T>> operands) {
     auto region = bodyRegion.pushOp(op, 3 + operands.size());
     auto id = newId<TypeToValue<T>>();
     region.pushIdUse(resultType);
@@ -583,142 +556,142 @@ public:
   }
 
   template <typename T>
-    requires(std::is_same_v<SIntType, T> ||
-             std::is_same_v<VectorOfType<SIntType>, T>)
-  TypeToValue<T> createSNegate(T resultType, TypeToValue<T> operand) {
+  requires(std::is_same_v<SIntType, T> ||
+           std::is_same_v<VectorOfType<SIntType>, T>)
+      TypeToValue<T> createSNegate(T resultType, TypeToValue<T> operand) {
     return createInst(spv::Op::OpSNegate, resultType, std::array{operand});
   }
 
   template <typename T>
-    requires(std::is_same_v<FloatType, T> ||
-             std::is_same_v<VectorOfType<FloatType>, T>)
-  TypeToValue<T> createFNegate(T resultType, TypeToValue<T> operand) {
+  requires(std::is_same_v<FloatType, T> ||
+           std::is_same_v<VectorOfType<FloatType>, T>)
+      TypeToValue<T> createFNegate(T resultType, TypeToValue<T> operand) {
     return createInst(spv::Op::OpFNegate, resultType, std::array{operand});
   }
 
   template <typename T>
-    requires(std::is_same_v<IntType, T> || std::is_base_of_v<IntType, T> ||
-             std::is_same_v<VectorOfType<IntType>, T> ||
-             std::is_same_v<VectorOfType<SIntType>, T> ||
-             std::is_same_v<VectorOfType<UIntType>, T>)
-  TypeToValue<T> createIAdd(T resultType, TypeToValue<T> operand1,
-                            TypeToValue<T> operand2) {
+  requires(std::is_same_v<IntType, T> || std::is_base_of_v<IntType, T> ||
+           std::is_same_v<VectorOfType<IntType>, T> ||
+           std::is_same_v<VectorOfType<SIntType>, T> ||
+           std::is_same_v<VectorOfType<UIntType>, T>)
+      TypeToValue<T> createIAdd(T resultType, TypeToValue<T> operand1,
+                                TypeToValue<T> operand2) {
     return createInst(spv::Op::OpIAdd, resultType,
                       std::array{operand1, operand2});
   }
 
   template <typename T>
-    requires(std::is_same_v<FloatType, T> ||
-             std::is_same_v<VectorOfType<FloatType>, T>)
-  TypeToValue<T> createFAdd(T resultType, TypeToValue<T> operand1,
-                            TypeToValue<T> operand2) {
+  requires(std::is_same_v<FloatType, T> ||
+           std::is_same_v<VectorOfType<FloatType>, T>)
+      TypeToValue<T> createFAdd(T resultType, TypeToValue<T> operand1,
+                                TypeToValue<T> operand2) {
     return createInst(spv::Op::OpFAdd, resultType,
                       std::array{operand1, operand2});
   }
 
   template <typename T>
-    requires(std::is_same_v<IntType, T> || std::is_base_of_v<IntType, T> ||
-             std::is_same_v<VectorOfType<IntType>, T> ||
-             std::is_same_v<VectorOfType<SIntType>, T> ||
-             std::is_same_v<VectorOfType<UIntType>, T>)
-  TypeToValue<T> createISub(T resultType, TypeToValue<T> operand1,
-                            TypeToValue<T> operand2) {
+  requires(std::is_same_v<IntType, T> || std::is_base_of_v<IntType, T> ||
+           std::is_same_v<VectorOfType<IntType>, T> ||
+           std::is_same_v<VectorOfType<SIntType>, T> ||
+           std::is_same_v<VectorOfType<UIntType>, T>)
+      TypeToValue<T> createISub(T resultType, TypeToValue<T> operand1,
+                                TypeToValue<T> operand2) {
     return createInst(spv::Op::OpISub, resultType,
                       std::array{operand1, operand2});
   }
 
   template <typename T>
-    requires(std::is_same_v<FloatType, T> ||
-             std::is_same_v<VectorOfType<FloatType>, T>)
-  TypeToValue<T> createFSub(T resultType, TypeToValue<T> operand1,
-                            TypeToValue<T> operand2) {
+  requires(std::is_same_v<FloatType, T> ||
+           std::is_same_v<VectorOfType<FloatType>, T>)
+      TypeToValue<T> createFSub(T resultType, TypeToValue<T> operand1,
+                                TypeToValue<T> operand2) {
     return createInst(spv::Op::OpFSub, resultType,
                       std::array{operand1, operand2});
   }
 
   template <typename T>
-    requires(std::is_same_v<IntType, T> || std::is_base_of_v<IntType, T> ||
-             std::is_same_v<VectorOfType<IntType>, T> ||
-             std::is_same_v<VectorOfType<SIntType>, T> ||
-             std::is_same_v<VectorOfType<UIntType>, T>)
-  TypeToValue<T> createIMul(T resultType, TypeToValue<T> operand1,
-                            TypeToValue<T> operand2) {
+  requires(std::is_same_v<IntType, T> || std::is_base_of_v<IntType, T> ||
+           std::is_same_v<VectorOfType<IntType>, T> ||
+           std::is_same_v<VectorOfType<SIntType>, T> ||
+           std::is_same_v<VectorOfType<UIntType>, T>)
+      TypeToValue<T> createIMul(T resultType, TypeToValue<T> operand1,
+                                TypeToValue<T> operand2) {
     return createInst(spv::Op::OpIMul, resultType,
                       std::array{operand1, operand2});
   }
 
   template <typename T>
-    requires(std::is_same_v<FloatType, T> ||
-             std::is_same_v<VectorOfType<FloatType>, T>)
-  TypeToValue<T> createFMul(T resultType, TypeToValue<T> operand1,
-                            TypeToValue<T> operand2) {
+  requires(std::is_same_v<FloatType, T> ||
+           std::is_same_v<VectorOfType<FloatType>, T>)
+      TypeToValue<T> createFMul(T resultType, TypeToValue<T> operand1,
+                                TypeToValue<T> operand2) {
     return createInst(spv::Op::OpFMul, resultType,
                       std::array{operand1, operand2});
   }
 
   template <typename T>
-    requires(std::is_same_v<UIntType, T> ||
-             std::is_same_v<VectorOfType<UIntType>, T>)
-  TypeToValue<T> createUDiv(T resultType, TypeToValue<T> operand1,
-                            TypeToValue<T> operand2) {
+  requires(std::is_same_v<UIntType, T> ||
+           std::is_same_v<VectorOfType<UIntType>, T>)
+      TypeToValue<T> createUDiv(T resultType, TypeToValue<T> operand1,
+                                TypeToValue<T> operand2) {
     return createInst(spv::Op::OpUDiv, resultType,
                       std::array{operand1, operand2});
   }
   template <typename T>
-    requires(std::is_same_v<SIntType, T> ||
-             std::is_same_v<VectorOfType<SIntType>, T>)
-  TypeToValue<T> createSDiv(T resultType, TypeToValue<T> operand1,
-                            TypeToValue<T> operand2) {
+  requires(std::is_same_v<SIntType, T> ||
+           std::is_same_v<VectorOfType<SIntType>, T>)
+      TypeToValue<T> createSDiv(T resultType, TypeToValue<T> operand1,
+                                TypeToValue<T> operand2) {
     return createInst(spv::Op::OpSDiv, resultType,
                       std::array{operand1, operand2});
   }
 
   template <typename T>
-    requires(std::is_same_v<FloatType, T> ||
-             std::is_same_v<VectorOfType<FloatType>, T>)
-  TypeToValue<T> createFDiv(T resultType, TypeToValue<T> operand1,
-                            TypeToValue<T> operand2) {
+  requires(std::is_same_v<FloatType, T> ||
+           std::is_same_v<VectorOfType<FloatType>, T>)
+      TypeToValue<T> createFDiv(T resultType, TypeToValue<T> operand1,
+                                TypeToValue<T> operand2) {
     return createInst(spv::Op::OpFDiv, resultType,
                       std::array{operand1, operand2});
   }
   template <typename T>
-    requires(std::is_same_v<UIntType, T> ||
-             std::is_same_v<VectorOfType<UIntType>, T>)
-  TypeToValue<T> createUMod(T resultType, TypeToValue<T> operand1,
-                            TypeToValue<T> operand2) {
+  requires(std::is_same_v<UIntType, T> ||
+           std::is_same_v<VectorOfType<UIntType>, T>)
+      TypeToValue<T> createUMod(T resultType, TypeToValue<T> operand1,
+                                TypeToValue<T> operand2) {
     return createInst(spv::Op::OpUMod, resultType,
                       std::array{operand1, operand2});
   }
   template <typename T>
-    requires(std::is_same_v<SIntType, T> ||
-             std::is_same_v<VectorOfType<SIntType>, T>)
-  TypeToValue<T> createSRem(T resultType, TypeToValue<T> operand1,
-                            TypeToValue<T> operand2) {
+  requires(std::is_same_v<SIntType, T> ||
+           std::is_same_v<VectorOfType<SIntType>, T>)
+      TypeToValue<T> createSRem(T resultType, TypeToValue<T> operand1,
+                                TypeToValue<T> operand2) {
     return createInst(spv::Op::OpSRem, resultType,
                       std::array{operand1, operand2});
   }
 
   template <typename T>
-    requires(std::is_same_v<SIntType, T> ||
-             std::is_same_v<VectorOfType<SIntType>, T>)
-  TypeToValue<T> createSMod(T resultType, TypeToValue<T> operand1,
-                            TypeToValue<T> operand2) {
+  requires(std::is_same_v<SIntType, T> ||
+           std::is_same_v<VectorOfType<SIntType>, T>)
+      TypeToValue<T> createSMod(T resultType, TypeToValue<T> operand1,
+                                TypeToValue<T> operand2) {
     return createInst(spv::Op::OpSMod, resultType,
                       std::array{operand1, operand2});
   }
   template <typename T>
-    requires(std::is_same_v<FloatType, T> ||
-             std::is_same_v<VectorOfType<FloatType>, T>)
-  TypeToValue<T> createFRem(T resultType, TypeToValue<T> operand1,
-                            TypeToValue<T> operand2) {
+  requires(std::is_same_v<FloatType, T> ||
+           std::is_same_v<VectorOfType<FloatType>, T>)
+      TypeToValue<T> createFRem(T resultType, TypeToValue<T> operand1,
+                                TypeToValue<T> operand2) {
     return createInst(spv::Op::OpFRem, resultType,
                       std::array{operand1, operand2});
   }
   template <typename T>
-    requires(std::is_same_v<FloatType, T> ||
-             std::is_same_v<VectorOfType<FloatType>, T>)
-  TypeToValue<T> createFMod(T resultType, TypeToValue<T> operand1,
-                            TypeToValue<T> operand2) {
+  requires(std::is_same_v<FloatType, T> ||
+           std::is_same_v<VectorOfType<FloatType>, T>)
+      TypeToValue<T> createFMod(T resultType, TypeToValue<T> operand1,
+                                TypeToValue<T> operand2) {
     return createInst(spv::Op::OpFMod, resultType,
                       std::array{operand1, operand2});
   }
@@ -795,9 +768,8 @@ public:
   }
 
   template <typename T>
-    requires(std::is_base_of_v<Type, T>)
-  TypeToValue<T> createPhi(T resultType,
-                           std::span<const std::pair<Value, Block>> values) {
+  requires(std::is_base_of_v<Type, T>) TypeToValue<T> createPhi(
+      T resultType, std::span<const std::pair<Value, Block>> values) {
     return cast<TypeToValue<T>>(
         createPhi(static_cast<Type>(resultType), values));
   }
@@ -883,8 +855,8 @@ public:
   }
 
   template <typename T>
-    requires(std::is_base_of_v<Type, T>)
-  TypeToValue<T> createLoad(T resultType, PointerValue pointer) {
+  requires(std::is_base_of_v<Type, T>)
+      TypeToValue<T> createLoad(T resultType, PointerValue pointer) {
     auto region = bodyRegion.pushOp(spv::Op::OpLoad, 4);
     auto id = newId<TypeToValue<T>>();
     region.pushIdUse(resultType);
@@ -1521,8 +1493,7 @@ public:
     return id;
   }
 
-  IntValue createImageQueryLevels(IntType resultType,
-                                  ImageValue sampledImage) {
+  IntValue createImageQueryLevels(IntType resultType, ImageValue sampledImage) {
     auto region = bodyRegion.pushOp(spv::Op::OpImageQueryLevels, 4);
     auto id = newId<IntValue>();
     region.pushIdUse(resultType);
@@ -1617,8 +1588,8 @@ public:
       : mIdGenerator(&idGenerator), capabilityRegion{1}, extensionRegion{1},
         extInstRegion{4}, memoryModelRegion{3}, entryPointRegion{1},
         executionModeRegion{1}, debugRegion{0}, annotationRegion{1},
-        globalRegion{1}, functionDeclRegion{1},
-        functionRegion{expInstructionsCount} {}
+        globalRegion{1}, functionDeclRegion{1}, functionRegion{
+                                                    expInstructionsCount} {}
 
   SpirvBuilder clone() const { return *this; }
 
@@ -1698,8 +1669,8 @@ public:
   }
 
   template <typename T>
-    requires(std::is_base_of_v<Type, T>)
-  TypeToValue<T> createUndef(T resultType) {
+  requires(std::is_base_of_v<Type, T>)
+      TypeToValue<T> createUndef(T resultType) {
     return cast<TypeToValue<T>>(createUndef(resultType));
   }
 
@@ -1985,8 +1956,8 @@ public:
   }
 
   template <typename T>
-    requires(std::is_base_of_v<Type, T>)
-  PointerToType<T> createTypePointer(spv::StorageClass storageClass, T type) {
+  requires(std::is_base_of_v<Type, T>) PointerToType<T> createTypePointer(
+      spv::StorageClass storageClass, T type) {
     return cast<PointerToType<T>>(
         createTypePointer(storageClass, static_cast<Type>(type)));
   }
@@ -2024,9 +1995,9 @@ public:
   }
 
   template <typename T>
-    requires(std::is_base_of_v<Type, T>)
-  ConstantValue<TypeToValue<T>>
-  createConstant(T type, std::span<const std::uint32_t> values) {
+  requires(std::is_base_of_v<Type, T>)
+      ConstantValue<TypeToValue<T>> createConstant(
+          T type, std::span<const std::uint32_t> values) {
     auto region = globalRegion.pushOp(spv::Op::OpConstant, 3 + values.size());
     auto id = newId<ConstantValue<TypeToValue<T>>>();
     region.pushIdUse(type);
@@ -2038,14 +2009,16 @@ public:
   }
 
   template <typename T>
-    requires(std::is_base_of_v<Type, T>)
-  ConstantValue<TypeToValue<T>> createConstant32(T type, std::uint32_t value) {
+  requires(std::is_base_of_v<Type, T>)
+      ConstantValue<TypeToValue<T>> createConstant32(T type,
+                                                     std::uint32_t value) {
     return createConstant(type, std::array{value});
   }
 
   template <typename T>
-    requires(std::is_base_of_v<Type, T>)
-  ConstantValue<TypeToValue<T>> createConstant64(T type, std::uint64_t value) {
+  requires(std::is_base_of_v<Type, T>)
+      ConstantValue<TypeToValue<T>> createConstant64(T type,
+                                                     std::uint64_t value) {
     return createConstant(type,
                           std::array{static_cast<std::uint32_t>(value),
                                      static_cast<std::uint32_t>(value >> 32)});
diff --git a/hw/amdgpu/lib/libspirv/include/spirv/spirv-instruction.hpp b/hw/amdgpu/lib/libspirv/include/spirv/spirv-instruction.hpp
index aaa8eb7fc..36dc27100 100644
--- a/hw/amdgpu/lib/libspirv/include/spirv/spirv-instruction.hpp
+++ b/hw/amdgpu/lib/libspirv/include/spirv/spirv-instruction.hpp
@@ -50,10 +50,10 @@ inline const InstructionInfo *getInstructionInfo(spv::Op opcode) {
     return &result;
   }
   case spv::Op::OpUndef: {
-    static InstructionInfo result = {
-        "OpUndef",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpUndef",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpSourceContinued: {
@@ -98,10 +98,10 @@ inline const InstructionInfo *getInstructionInfo(spv::Op opcode) {
     return &result;
   }
   case spv::Op::OpExtInst: {
-    static InstructionInfo result = {
-        "OpExtInst",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpExtInst",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpMemoryModel: {
@@ -165,9 +165,8 @@ inline const InstructionInfo *getInstructionInfo(spv::Op opcode) {
     return &result;
   }
   case spv::Op::OpTypeSampledImage: {
-    static InstructionInfo result = {"OpTypeSampledImage",
-                                     InstructionFlags::HasResult,
-                                     {}};
+    static InstructionInfo result = {
+        "OpTypeSampledImage", InstructionFlags::HasResult, {}};
     return &result;
   }
   case spv::Op::OpTypeArray: {
@@ -176,9 +175,8 @@ inline const InstructionInfo *getInstructionInfo(spv::Op opcode) {
     return &result;
   }
   case spv::Op::OpTypeRuntimeArray: {
-    static InstructionInfo result = {"OpTypeRuntimeArray",
-                                     InstructionFlags::HasResult,
-                                     {}};
+    static InstructionInfo result = {
+        "OpTypeRuntimeArray", InstructionFlags::HasResult, {}};
     return &result;
   }
   case spv::Op::OpTypeStruct: {
@@ -207,9 +205,8 @@ inline const InstructionInfo *getInstructionInfo(spv::Op opcode) {
     return &result;
   }
   case spv::Op::OpTypeDeviceEvent: {
-    static InstructionInfo result = {"OpTypeDeviceEvent",
-                                     InstructionFlags::HasResult,
-                                     {}};
+    static InstructionInfo result = {
+        "OpTypeDeviceEvent", InstructionFlags::HasResult, {}};
     return &result;
   }
   case spv::Op::OpTypeReserveId: {
@@ -233,94 +230,94 @@ inline const InstructionInfo *getInstructionInfo(spv::Op opcode) {
     return &result;
   }
   case spv::Op::OpConstantTrue: {
-    static InstructionInfo result = {
-        "OpConstantTrue",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpConstantTrue",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpConstantFalse: {
-    static InstructionInfo result = {
-        "OpConstantFalse",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpConstantFalse",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpConstant: {
-    static InstructionInfo result = {
-        "OpConstant",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpConstant",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpConstantComposite: {
-    static InstructionInfo result = {
-        "OpConstantComposite",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpConstantComposite",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpConstantSampler: {
-    static InstructionInfo result = {
-        "OpConstantSampler",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpConstantSampler",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpConstantNull: {
-    static InstructionInfo result = {
-        "OpConstantNull",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpConstantNull",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpSpecConstantTrue: {
-    static InstructionInfo result = {
-        "OpSpecConstantTrue",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpSpecConstantTrue",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpSpecConstantFalse: {
-    static InstructionInfo result = {
-        "OpSpecConstantFalse",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpSpecConstantFalse",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpSpecConstant: {
-    static InstructionInfo result = {
-        "OpSpecConstant",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpSpecConstant",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpSpecConstantComposite: {
-    static InstructionInfo result = {
-        "OpSpecConstantComposite",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpSpecConstantComposite",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpSpecConstantOp: {
-    static InstructionInfo result = {
-        "OpSpecConstantOp",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpSpecConstantOp",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFunction: {
-    static InstructionInfo result = {
-        "OpFunction",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFunction",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFunctionParameter: {
-    static InstructionInfo result = {
-        "OpFunctionParameter",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFunctionParameter",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFunctionEnd: {
@@ -329,31 +326,31 @@ inline const InstructionInfo *getInstructionInfo(spv::Op opcode) {
     return &result;
   }
   case spv::Op::OpFunctionCall: {
-    static InstructionInfo result = {
-        "OpFunctionCall",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFunctionCall",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpVariable: {
-    static InstructionInfo result = {
-        "OpVariable",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpVariable",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageTexelPointer: {
-    static InstructionInfo result = {
-        "OpImageTexelPointer",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageTexelPointer",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpLoad: {
-    static InstructionInfo result = {
-        "OpLoad",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpLoad",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpStore: {
@@ -371,45 +368,45 @@ inline const InstructionInfo *getInstructionInfo(spv::Op opcode) {
     return &result;
   }
   case spv::Op::OpAccessChain: {
-    static InstructionInfo result = {
-        "OpAccessChain",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpAccessChain",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpInBoundsAccessChain: {
-    static InstructionInfo result = {
-        "OpInBoundsAccessChain",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpInBoundsAccessChain",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpPtrAccessChain: {
-    static InstructionInfo result = {
-        "OpPtrAccessChain",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpPtrAccessChain",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpArrayLength: {
-    static InstructionInfo result = {
-        "OpArrayLength",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpArrayLength",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGenericPtrMemSemantics: {
-    static InstructionInfo result = {
-        "OpGenericPtrMemSemantics",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGenericPtrMemSemantics",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpInBoundsPtrAccessChain: {
-    static InstructionInfo result = {
-        "OpInBoundsPtrAccessChain",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpInBoundsPtrAccessChain",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpDecorate: {
@@ -422,9 +419,8 @@ inline const InstructionInfo *getInstructionInfo(spv::Op opcode) {
     return &result;
   }
   case spv::Op::OpDecorationGroup: {
-    static InstructionInfo result = {"OpDecorationGroup",
-                                     InstructionFlags::HasResult,
-                                     {}};
+    static InstructionInfo result = {
+        "OpDecorationGroup", InstructionFlags::HasResult, {}};
     return &result;
   }
   case spv::Op::OpGroupDecorate: {
@@ -438,150 +434,150 @@ inline const InstructionInfo *getInstructionInfo(spv::Op opcode) {
     return &result;
   }
   case spv::Op::OpVectorExtractDynamic: {
-    static InstructionInfo result = {
-        "OpVectorExtractDynamic",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpVectorExtractDynamic",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpVectorInsertDynamic: {
-    static InstructionInfo result = {
-        "OpVectorInsertDynamic",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpVectorInsertDynamic",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpVectorShuffle: {
-    static InstructionInfo result = {
-        "OpVectorShuffle",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpVectorShuffle",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpCompositeConstruct: {
-    static InstructionInfo result = {
-        "OpCompositeConstruct",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpCompositeConstruct",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpCompositeExtract: {
-    static InstructionInfo result = {
-        "OpCompositeExtract",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpCompositeExtract",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpCompositeInsert: {
-    static InstructionInfo result = {
-        "OpCompositeInsert",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpCompositeInsert",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpCopyObject: {
-    static InstructionInfo result = {
-        "OpCopyObject",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpCopyObject",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpTranspose: {
-    static InstructionInfo result = {
-        "OpTranspose",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpTranspose",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpSampledImage: {
-    static InstructionInfo result = {
-        "OpSampledImage",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpSampledImage",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageSampleImplicitLod: {
-    static InstructionInfo result = {
-        "OpImageSampleImplicitLod",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageSampleImplicitLod",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageSampleExplicitLod: {
-    static InstructionInfo result = {
-        "OpImageSampleExplicitLod",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageSampleExplicitLod",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageSampleDrefImplicitLod: {
-    static InstructionInfo result = {
-        "OpImageSampleDrefImplicitLod",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageSampleDrefImplicitLod",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageSampleDrefExplicitLod: {
-    static InstructionInfo result = {
-        "OpImageSampleDrefExplicitLod",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageSampleDrefExplicitLod",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageSampleProjImplicitLod: {
-    static InstructionInfo result = {
-        "OpImageSampleProjImplicitLod",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageSampleProjImplicitLod",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageSampleProjExplicitLod: {
-    static InstructionInfo result = {
-        "OpImageSampleProjExplicitLod",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageSampleProjExplicitLod",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageSampleProjDrefImplicitLod: {
-    static InstructionInfo result = {
-        "OpImageSampleProjDrefImplicitLod",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageSampleProjDrefImplicitLod",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageSampleProjDrefExplicitLod: {
-    static InstructionInfo result = {
-        "OpImageSampleProjDrefExplicitLod",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageSampleProjDrefExplicitLod",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageFetch: {
-    static InstructionInfo result = {
-        "OpImageFetch",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageFetch",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageGather: {
-    static InstructionInfo result = {
-        "OpImageGather",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageGather",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageDrefGather: {
-    static InstructionInfo result = {
-        "OpImageDrefGather",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageDrefGather",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageRead: {
-    static InstructionInfo result = {
-        "OpImageRead",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageRead",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageWrite: {
@@ -590,773 +586,773 @@ inline const InstructionInfo *getInstructionInfo(spv::Op opcode) {
     return &result;
   }
   case spv::Op::OpImage: {
-    static InstructionInfo result = {
-        "OpImage",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImage",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageQueryFormat: {
-    static InstructionInfo result = {
-        "OpImageQueryFormat",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageQueryFormat",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageQueryOrder: {
-    static InstructionInfo result = {
-        "OpImageQueryOrder",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageQueryOrder",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageQuerySizeLod: {
-    static InstructionInfo result = {
-        "OpImageQuerySizeLod",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageQuerySizeLod",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageQuerySize: {
-    static InstructionInfo result = {
-        "OpImageQuerySize",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageQuerySize",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageQueryLod: {
-    static InstructionInfo result = {
-        "OpImageQueryLod",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageQueryLod",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageQueryLevels: {
-    static InstructionInfo result = {
-        "OpImageQueryLevels",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageQueryLevels",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageQuerySamples: {
-    static InstructionInfo result = {
-        "OpImageQuerySamples",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageQuerySamples",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpConvertFToU: {
-    static InstructionInfo result = {
-        "OpConvertFToU",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpConvertFToU",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpConvertFToS: {
-    static InstructionInfo result = {
-        "OpConvertFToS",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpConvertFToS",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpConvertSToF: {
-    static InstructionInfo result = {
-        "OpConvertSToF",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpConvertSToF",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpConvertUToF: {
-    static InstructionInfo result = {
-        "OpConvertUToF",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpConvertUToF",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpUConvert: {
-    static InstructionInfo result = {
-        "OpUConvert",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpUConvert",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpSConvert: {
-    static InstructionInfo result = {
-        "OpSConvert",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpSConvert",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFConvert: {
-    static InstructionInfo result = {
-        "OpFConvert",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFConvert",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpQuantizeToF16: {
-    static InstructionInfo result = {
-        "OpQuantizeToF16",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpQuantizeToF16",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpConvertPtrToU: {
-    static InstructionInfo result = {
-        "OpConvertPtrToU",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpConvertPtrToU",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpSatConvertSToU: {
-    static InstructionInfo result = {
-        "OpSatConvertSToU",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpSatConvertSToU",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpSatConvertUToS: {
-    static InstructionInfo result = {
-        "OpSatConvertUToS",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpSatConvertUToS",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpConvertUToPtr: {
-    static InstructionInfo result = {
-        "OpConvertUToPtr",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpConvertUToPtr",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpPtrCastToGeneric: {
-    static InstructionInfo result = {
-        "OpPtrCastToGeneric",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpPtrCastToGeneric",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGenericCastToPtr: {
-    static InstructionInfo result = {
-        "OpGenericCastToPtr",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGenericCastToPtr",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGenericCastToPtrExplicit: {
-    static InstructionInfo result = {
-        "OpGenericCastToPtrExplicit",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGenericCastToPtrExplicit",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpBitcast: {
-    static InstructionInfo result = {
-        "OpBitcast",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpBitcast",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpSNegate: {
-    static InstructionInfo result = {
-        "OpSNegate",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpSNegate",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFNegate: {
-    static InstructionInfo result = {
-        "OpFNegate",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFNegate",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpIAdd: {
-    static InstructionInfo result = {
-        "OpIAdd",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpIAdd",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFAdd: {
-    static InstructionInfo result = {
-        "OpFAdd",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFAdd",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpISub: {
-    static InstructionInfo result = {
-        "OpISub",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpISub",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFSub: {
-    static InstructionInfo result = {
-        "OpFSub",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFSub",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpIMul: {
-    static InstructionInfo result = {
-        "OpIMul",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpIMul",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFMul: {
-    static InstructionInfo result = {
-        "OpFMul",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFMul",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpUDiv: {
-    static InstructionInfo result = {
-        "OpUDiv",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpUDiv",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpSDiv: {
-    static InstructionInfo result = {
-        "OpSDiv",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpSDiv",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFDiv: {
-    static InstructionInfo result = {
-        "OpFDiv",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFDiv",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpUMod: {
-    static InstructionInfo result = {
-        "OpUMod",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpUMod",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpSRem: {
-    static InstructionInfo result = {
-        "OpSRem",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpSRem",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpSMod: {
-    static InstructionInfo result = {
-        "OpSMod",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpSMod",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFRem: {
-    static InstructionInfo result = {
-        "OpFRem",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFRem",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFMod: {
-    static InstructionInfo result = {
-        "OpFMod",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFMod",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpVectorTimesScalar: {
-    static InstructionInfo result = {
-        "OpVectorTimesScalar",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpVectorTimesScalar",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpMatrixTimesScalar: {
-    static InstructionInfo result = {
-        "OpMatrixTimesScalar",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpMatrixTimesScalar",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpVectorTimesMatrix: {
-    static InstructionInfo result = {
-        "OpVectorTimesMatrix",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpVectorTimesMatrix",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpMatrixTimesVector: {
-    static InstructionInfo result = {
-        "OpMatrixTimesVector",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpMatrixTimesVector",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpMatrixTimesMatrix: {
-    static InstructionInfo result = {
-        "OpMatrixTimesMatrix",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpMatrixTimesMatrix",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpOuterProduct: {
-    static InstructionInfo result = {
-        "OpOuterProduct",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpOuterProduct",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpDot: {
-    static InstructionInfo result = {
-        "OpDot",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpDot",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpIAddCarry: {
-    static InstructionInfo result = {
-        "OpIAddCarry",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpIAddCarry",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpISubBorrow: {
-    static InstructionInfo result = {
-        "OpISubBorrow",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpISubBorrow",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpUMulExtended: {
-    static InstructionInfo result = {
-        "OpUMulExtended",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpUMulExtended",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpSMulExtended: {
-    static InstructionInfo result = {
-        "OpSMulExtended",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpSMulExtended",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpAny: {
-    static InstructionInfo result = {
-        "OpAny",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpAny",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpAll: {
-    static InstructionInfo result = {
-        "OpAll",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpAll",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpIsNan: {
-    static InstructionInfo result = {
-        "OpIsNan",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpIsNan",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpIsInf: {
-    static InstructionInfo result = {
-        "OpIsInf",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpIsInf",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpIsFinite: {
-    static InstructionInfo result = {
-        "OpIsFinite",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpIsFinite",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpIsNormal: {
-    static InstructionInfo result = {
-        "OpIsNormal",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpIsNormal",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpSignBitSet: {
-    static InstructionInfo result = {
-        "OpSignBitSet",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpSignBitSet",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpLessOrGreater: {
-    static InstructionInfo result = {
-        "OpLessOrGreater",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpLessOrGreater",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpOrdered: {
-    static InstructionInfo result = {
-        "OpOrdered",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpOrdered",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpUnordered: {
-    static InstructionInfo result = {
-        "OpUnordered",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpUnordered",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpLogicalEqual: {
-    static InstructionInfo result = {
-        "OpLogicalEqual",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpLogicalEqual",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpLogicalNotEqual: {
-    static InstructionInfo result = {
-        "OpLogicalNotEqual",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpLogicalNotEqual",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpLogicalOr: {
-    static InstructionInfo result = {
-        "OpLogicalOr",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpLogicalOr",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpLogicalAnd: {
-    static InstructionInfo result = {
-        "OpLogicalAnd",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpLogicalAnd",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpLogicalNot: {
-    static InstructionInfo result = {
-        "OpLogicalNot",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpLogicalNot",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpSelect: {
-    static InstructionInfo result = {
-        "OpSelect",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpSelect",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpIEqual: {
-    static InstructionInfo result = {
-        "OpIEqual",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpIEqual",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpINotEqual: {
-    static InstructionInfo result = {
-        "OpINotEqual",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpINotEqual",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpUGreaterThan: {
-    static InstructionInfo result = {
-        "OpUGreaterThan",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpUGreaterThan",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpSGreaterThan: {
-    static InstructionInfo result = {
-        "OpSGreaterThan",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpSGreaterThan",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpUGreaterThanEqual: {
-    static InstructionInfo result = {
-        "OpUGreaterThanEqual",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpUGreaterThanEqual",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpSGreaterThanEqual: {
-    static InstructionInfo result = {
-        "OpSGreaterThanEqual",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpSGreaterThanEqual",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpULessThan: {
-    static InstructionInfo result = {
-        "OpULessThan",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpULessThan",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpSLessThan: {
-    static InstructionInfo result = {
-        "OpSLessThan",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpSLessThan",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpULessThanEqual: {
-    static InstructionInfo result = {
-        "OpULessThanEqual",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpULessThanEqual",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpSLessThanEqual: {
-    static InstructionInfo result = {
-        "OpSLessThanEqual",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpSLessThanEqual",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFOrdEqual: {
-    static InstructionInfo result = {
-        "OpFOrdEqual",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFOrdEqual",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFUnordEqual: {
-    static InstructionInfo result = {
-        "OpFUnordEqual",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFUnordEqual",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFOrdNotEqual: {
-    static InstructionInfo result = {
-        "OpFOrdNotEqual",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFOrdNotEqual",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFUnordNotEqual: {
-    static InstructionInfo result = {
-        "OpFUnordNotEqual",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFUnordNotEqual",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFOrdLessThan: {
-    static InstructionInfo result = {
-        "OpFOrdLessThan",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFOrdLessThan",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFUnordLessThan: {
-    static InstructionInfo result = {
-        "OpFUnordLessThan",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFUnordLessThan",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFOrdGreaterThan: {
-    static InstructionInfo result = {
-        "OpFOrdGreaterThan",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFOrdGreaterThan",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFUnordGreaterThan: {
-    static InstructionInfo result = {
-        "OpFUnordGreaterThan",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFUnordGreaterThan",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFOrdLessThanEqual: {
-    static InstructionInfo result = {
-        "OpFOrdLessThanEqual",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFOrdLessThanEqual",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFUnordLessThanEqual: {
-    static InstructionInfo result = {
-        "OpFUnordLessThanEqual",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFUnordLessThanEqual",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFOrdGreaterThanEqual: {
-    static InstructionInfo result = {
-        "OpFOrdGreaterThanEqual",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFOrdGreaterThanEqual",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFUnordGreaterThanEqual: {
-    static InstructionInfo result = {
-        "OpFUnordGreaterThanEqual",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFUnordGreaterThanEqual",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpShiftRightLogical: {
-    static InstructionInfo result = {
-        "OpShiftRightLogical",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpShiftRightLogical",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpShiftRightArithmetic: {
-    static InstructionInfo result = {
-        "OpShiftRightArithmetic",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpShiftRightArithmetic",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpShiftLeftLogical: {
-    static InstructionInfo result = {
-        "OpShiftLeftLogical",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpShiftLeftLogical",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpBitwiseOr: {
-    static InstructionInfo result = {
-        "OpBitwiseOr",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpBitwiseOr",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpBitwiseXor: {
-    static InstructionInfo result = {
-        "OpBitwiseXor",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpBitwiseXor",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpBitwiseAnd: {
-    static InstructionInfo result = {
-        "OpBitwiseAnd",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpBitwiseAnd",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpNot: {
-    static InstructionInfo result = {
-        "OpNot",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpNot",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpBitFieldInsert: {
-    static InstructionInfo result = {
-        "OpBitFieldInsert",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpBitFieldInsert",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpBitFieldSExtract: {
-    static InstructionInfo result = {
-        "OpBitFieldSExtract",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpBitFieldSExtract",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpBitFieldUExtract: {
-    static InstructionInfo result = {
-        "OpBitFieldUExtract",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpBitFieldUExtract",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpBitReverse: {
-    static InstructionInfo result = {
-        "OpBitReverse",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpBitReverse",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpBitCount: {
-    static InstructionInfo result = {
-        "OpBitCount",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpBitCount",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpDPdx: {
-    static InstructionInfo result = {
-        "OpDPdx",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpDPdx",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpDPdy: {
-    static InstructionInfo result = {
-        "OpDPdy",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpDPdy",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFwidth: {
-    static InstructionInfo result = {
-        "OpFwidth",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFwidth",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpDPdxFine: {
-    static InstructionInfo result = {
-        "OpDPdxFine",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpDPdxFine",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpDPdyFine: {
-    static InstructionInfo result = {
-        "OpDPdyFine",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpDPdyFine",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFwidthFine: {
-    static InstructionInfo result = {
-        "OpFwidthFine",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFwidthFine",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpDPdxCoarse: {
-    static InstructionInfo result = {
-        "OpDPdxCoarse",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpDPdxCoarse",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpDPdyCoarse: {
-    static InstructionInfo result = {
-        "OpDPdyCoarse",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpDPdyCoarse",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpFwidthCoarse: {
-    static InstructionInfo result = {
-        "OpFwidthCoarse",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpFwidthCoarse",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpEmitVertex: {
@@ -1390,10 +1386,10 @@ inline const InstructionInfo *getInstructionInfo(spv::Op opcode) {
     return &result;
   }
   case spv::Op::OpAtomicLoad: {
-    static InstructionInfo result = {
-        "OpAtomicLoad",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpAtomicLoad",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpAtomicStore: {
@@ -1402,108 +1398,108 @@ inline const InstructionInfo *getInstructionInfo(spv::Op opcode) {
     return &result;
   }
   case spv::Op::OpAtomicExchange: {
-    static InstructionInfo result = {
-        "OpAtomicExchange",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpAtomicExchange",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpAtomicCompareExchange: {
-    static InstructionInfo result = {
-        "OpAtomicCompareExchange",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpAtomicCompareExchange",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpAtomicCompareExchangeWeak: {
-    static InstructionInfo result = {
-        "OpAtomicCompareExchangeWeak",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpAtomicCompareExchangeWeak",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpAtomicIIncrement: {
-    static InstructionInfo result = {
-        "OpAtomicIIncrement",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpAtomicIIncrement",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpAtomicIDecrement: {
-    static InstructionInfo result = {
-        "OpAtomicIDecrement",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpAtomicIDecrement",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpAtomicIAdd: {
-    static InstructionInfo result = {
-        "OpAtomicIAdd",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpAtomicIAdd",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpAtomicISub: {
-    static InstructionInfo result = {
-        "OpAtomicISub",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpAtomicISub",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpAtomicSMin: {
-    static InstructionInfo result = {
-        "OpAtomicSMin",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpAtomicSMin",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpAtomicUMin: {
-    static InstructionInfo result = {
-        "OpAtomicUMin",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpAtomicUMin",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpAtomicSMax: {
-    static InstructionInfo result = {
-        "OpAtomicSMax",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpAtomicSMax",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpAtomicUMax: {
-    static InstructionInfo result = {
-        "OpAtomicUMax",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpAtomicUMax",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpAtomicAnd: {
-    static InstructionInfo result = {
-        "OpAtomicAnd",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpAtomicAnd",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpAtomicOr: {
-    static InstructionInfo result = {
-        "OpAtomicOr",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpAtomicOr",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpAtomicXor: {
-    static InstructionInfo result = {
-        "OpAtomicXor",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpAtomicXor",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpPhi: {
-    static InstructionInfo result = {
-        "OpPhi",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpPhi",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpLoopMerge: {
@@ -1562,10 +1558,10 @@ inline const InstructionInfo *getInstructionInfo(spv::Op opcode) {
     return &result;
   }
   case spv::Op::OpGroupAsyncCopy: {
-    static InstructionInfo result = {
-        "OpGroupAsyncCopy",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupAsyncCopy",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupWaitEvents: {
@@ -1574,122 +1570,122 @@ inline const InstructionInfo *getInstructionInfo(spv::Op opcode) {
     return &result;
   }
   case spv::Op::OpGroupAll: {
-    static InstructionInfo result = {
-        "OpGroupAll",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupAll",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupAny: {
-    static InstructionInfo result = {
-        "OpGroupAny",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupAny",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupBroadcast: {
-    static InstructionInfo result = {
-        "OpGroupBroadcast",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupBroadcast",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupIAdd: {
-    static InstructionInfo result = {
-        "OpGroupIAdd",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupIAdd",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupFAdd: {
-    static InstructionInfo result = {
-        "OpGroupFAdd",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupFAdd",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupFMin: {
-    static InstructionInfo result = {
-        "OpGroupFMin",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupFMin",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupUMin: {
-    static InstructionInfo result = {
-        "OpGroupUMin",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupUMin",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupSMin: {
-    static InstructionInfo result = {
-        "OpGroupSMin",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupSMin",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupFMax: {
-    static InstructionInfo result = {
-        "OpGroupFMax",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupFMax",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupUMax: {
-    static InstructionInfo result = {
-        "OpGroupUMax",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupUMax",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupSMax: {
-    static InstructionInfo result = {
-        "OpGroupSMax",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupSMax",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpReadPipe: {
-    static InstructionInfo result = {
-        "OpReadPipe",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpReadPipe",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpWritePipe: {
-    static InstructionInfo result = {
-        "OpWritePipe",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpWritePipe",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpReservedReadPipe: {
-    static InstructionInfo result = {
-        "OpReservedReadPipe",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpReservedReadPipe",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpReservedWritePipe: {
-    static InstructionInfo result = {
-        "OpReservedWritePipe",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpReservedWritePipe",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpReserveReadPipePackets: {
-    static InstructionInfo result = {
-        "OpReserveReadPipePackets",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpReserveReadPipePackets",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpReserveWritePipePackets: {
-    static InstructionInfo result = {
-        "OpReserveWritePipePackets",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpReserveWritePipePackets",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpCommitReadPipe: {
@@ -1703,38 +1699,38 @@ inline const InstructionInfo *getInstructionInfo(spv::Op opcode) {
     return &result;
   }
   case spv::Op::OpIsValidReserveId: {
-    static InstructionInfo result = {
-        "OpIsValidReserveId",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpIsValidReserveId",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGetNumPipePackets: {
-    static InstructionInfo result = {
-        "OpGetNumPipePackets",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGetNumPipePackets",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGetMaxPipePackets: {
-    static InstructionInfo result = {
-        "OpGetMaxPipePackets",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGetMaxPipePackets",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupReserveReadPipePackets: {
-    static InstructionInfo result = {
-        "OpGroupReserveReadPipePackets",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupReserveReadPipePackets",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupReserveWritePipePackets: {
-    static InstructionInfo result = {
-        "OpGroupReserveWritePipePackets",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupReserveWritePipePackets",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupCommitReadPipe: {
@@ -1748,38 +1744,38 @@ inline const InstructionInfo *getInstructionInfo(spv::Op opcode) {
     return &result;
   }
   case spv::Op::OpEnqueueMarker: {
-    static InstructionInfo result = {
-        "OpEnqueueMarker",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpEnqueueMarker",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpEnqueueKernel: {
-    static InstructionInfo result = {
-        "OpEnqueueKernel",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpEnqueueKernel",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGetKernelNDrangeSubGroupCount: {
-    static InstructionInfo result = {
-        "OpGetKernelNDrangeSubGroupCount",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGetKernelNDrangeSubGroupCount",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGetKernelNDrangeMaxSubGroupSize: {
-    static InstructionInfo result = {
-        "OpGetKernelNDrangeMaxSubGroupSize",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGetKernelNDrangeMaxSubGroupSize",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGetKernelWorkGroupSize: {
-    static InstructionInfo result = {
-        "OpGetKernelWorkGroupSize",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGetKernelWorkGroupSize",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGetKernelPreferredWorkGroupSizeMultiple: {
@@ -1800,17 +1796,17 @@ inline const InstructionInfo *getInstructionInfo(spv::Op opcode) {
     return &result;
   }
   case spv::Op::OpCreateUserEvent: {
-    static InstructionInfo result = {
-        "OpCreateUserEvent",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpCreateUserEvent",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpIsValidEvent: {
-    static InstructionInfo result = {
-        "OpIsValidEvent",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpIsValidEvent",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpSetUserEventStatus: {
@@ -1824,101 +1820,101 @@ inline const InstructionInfo *getInstructionInfo(spv::Op opcode) {
     return &result;
   }
   case spv::Op::OpGetDefaultQueue: {
-    static InstructionInfo result = {
-        "OpGetDefaultQueue",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGetDefaultQueue",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpBuildNDRange: {
-    static InstructionInfo result = {
-        "OpBuildNDRange",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpBuildNDRange",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageSparseSampleImplicitLod: {
-    static InstructionInfo result = {
-        "OpImageSparseSampleImplicitLod",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageSparseSampleImplicitLod",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageSparseSampleExplicitLod: {
-    static InstructionInfo result = {
-        "OpImageSparseSampleExplicitLod",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageSparseSampleExplicitLod",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageSparseSampleDrefImplicitLod: {
-    static InstructionInfo result = {
-        "OpImageSparseSampleDrefImplicitLod",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageSparseSampleDrefImplicitLod",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageSparseSampleDrefExplicitLod: {
-    static InstructionInfo result = {
-        "OpImageSparseSampleDrefExplicitLod",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageSparseSampleDrefExplicitLod",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageSparseSampleProjImplicitLod: {
-    static InstructionInfo result = {
-        "OpImageSparseSampleProjImplicitLod",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageSparseSampleProjImplicitLod",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageSparseSampleProjExplicitLod: {
-    static InstructionInfo result = {
-        "OpImageSparseSampleProjExplicitLod",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageSparseSampleProjExplicitLod",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageSparseSampleProjDrefImplicitLod: {
-    static InstructionInfo result = {
-        "OpImageSparseSampleProjDrefImplicitLod",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageSparseSampleProjDrefImplicitLod",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageSparseSampleProjDrefExplicitLod: {
-    static InstructionInfo result = {
-        "OpImageSparseSampleProjDrefExplicitLod",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageSparseSampleProjDrefExplicitLod",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageSparseFetch: {
-    static InstructionInfo result = {
-        "OpImageSparseFetch",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageSparseFetch",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageSparseGather: {
-    static InstructionInfo result = {
-        "OpImageSparseGather",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageSparseGather",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageSparseDrefGather: {
-    static InstructionInfo result = {
-        "OpImageSparseDrefGather",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageSparseDrefGather",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpImageSparseTexelsResident: {
-    static InstructionInfo result = {
-        "OpImageSparseTexelsResident",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageSparseTexelsResident",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpNoLine: {
@@ -1926,10 +1922,10 @@ inline const InstructionInfo *getInstructionInfo(spv::Op opcode) {
     return &result;
   }
   case spv::Op::OpAtomicFlagTestAndSet: {
-    static InstructionInfo result = {
-        "OpAtomicFlagTestAndSet",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpAtomicFlagTestAndSet",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpAtomicFlagClear: {
@@ -1938,64 +1934,62 @@ inline const InstructionInfo *getInstructionInfo(spv::Op opcode) {
     return &result;
   }
   case spv::Op::OpImageSparseRead: {
-    static InstructionInfo result = {
-        "OpImageSparseRead",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpImageSparseRead",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpSizeOf: {
-    static InstructionInfo result = {
-        "OpSizeOf",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpSizeOf",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpTypePipeStorage: {
-    static InstructionInfo result = {"OpTypePipeStorage",
-                                     InstructionFlags::HasResult,
-                                     {}};
+    static InstructionInfo result = {
+        "OpTypePipeStorage", InstructionFlags::HasResult, {}};
     return &result;
   }
   case spv::Op::OpConstantPipeStorage: {
-    static InstructionInfo result = {
-        "OpConstantPipeStorage",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
-    return &result;
-  }
-  case spv::Op::OpCreatePipeFromPipeStorage: {
-    static InstructionInfo result = {
-        "OpCreatePipeFromPipeStorage",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
-    return &result;
-  }
-  case spv::Op::OpGetKernelLocalSizeForSubgroupCount: {
-    static InstructionInfo result = {
-        "OpGetKernelLocalSizeForSubgroupCount",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
-    return &result;
-  }
-  case spv::Op::OpGetKernelMaxNumSubgroups: {
-    static InstructionInfo result = {
-        "OpGetKernelMaxNumSubgroups",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
-    return &result;
-  }
-  case spv::Op::OpTypeNamedBarrier: {
-    static InstructionInfo result = {"OpTypeNamedBarrier",
-                                     InstructionFlags::HasResult,
+    static InstructionInfo result = {"OpConstantPipeStorage",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
                                      {}};
     return &result;
   }
-  case spv::Op::OpNamedBarrierInitialize: {
+  case spv::Op::OpCreatePipeFromPipeStorage: {
+    static InstructionInfo result = {"OpCreatePipeFromPipeStorage",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
+    return &result;
+  }
+  case spv::Op::OpGetKernelLocalSizeForSubgroupCount: {
+    static InstructionInfo result = {"OpGetKernelLocalSizeForSubgroupCount",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
+    return &result;
+  }
+  case spv::Op::OpGetKernelMaxNumSubgroups: {
+    static InstructionInfo result = {"OpGetKernelMaxNumSubgroups",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
+    return &result;
+  }
+  case spv::Op::OpTypeNamedBarrier: {
     static InstructionInfo result = {
-        "OpNamedBarrierInitialize",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+        "OpTypeNamedBarrier", InstructionFlags::HasResult, {}};
+    return &result;
+  }
+  case spv::Op::OpNamedBarrierInitialize: {
+    static InstructionInfo result = {"OpNamedBarrierInitialize",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpMemoryNamedBarrier: {
@@ -2019,269 +2013,269 @@ inline const InstructionInfo *getInstructionInfo(spv::Op opcode) {
     return &result;
   }
   case spv::Op::OpGroupNonUniformElect: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformElect",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformElect",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformAll: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformAll",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformAll",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformAny: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformAny",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformAny",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformAllEqual: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformAllEqual",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformAllEqual",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformBroadcast: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformBroadcast",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformBroadcast",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformBroadcastFirst: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformBroadcastFirst",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformBroadcastFirst",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformBallot: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformBallot",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformBallot",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformInverseBallot: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformInverseBallot",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformInverseBallot",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformBallotBitExtract: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformBallotBitExtract",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformBallotBitExtract",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformBallotBitCount: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformBallotBitCount",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformBallotBitCount",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformBallotFindLSB: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformBallotFindLSB",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformBallotFindLSB",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformBallotFindMSB: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformBallotFindMSB",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformBallotFindMSB",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformShuffle: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformShuffle",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformShuffle",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformShuffleXor: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformShuffleXor",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformShuffleXor",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformShuffleUp: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformShuffleUp",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformShuffleUp",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformShuffleDown: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformShuffleDown",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformShuffleDown",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformIAdd: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformIAdd",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformIAdd",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformFAdd: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformFAdd",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformFAdd",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformIMul: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformIMul",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformIMul",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformFMul: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformFMul",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformFMul",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformSMin: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformSMin",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformSMin",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformUMin: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformUMin",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformUMin",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformFMin: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformFMin",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformFMin",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformSMax: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformSMax",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformSMax",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformUMax: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformUMax",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformUMax",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformFMax: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformFMax",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformFMax",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformBitwiseAnd: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformBitwiseAnd",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformBitwiseAnd",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformBitwiseOr: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformBitwiseOr",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformBitwiseOr",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformBitwiseXor: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformBitwiseXor",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformBitwiseXor",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformLogicalAnd: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformLogicalAnd",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformLogicalAnd",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformLogicalOr: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformLogicalOr",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformLogicalOr",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformLogicalXor: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformLogicalXor",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformLogicalXor",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformQuadBroadcast: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformQuadBroadcast",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformQuadBroadcast",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpGroupNonUniformQuadSwap: {
-    static InstructionInfo result = {
-        "OpGroupNonUniformQuadSwap",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpGroupNonUniformQuadSwap",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpCopyLogical: {
-    static InstructionInfo result = {
-        "OpCopyLogical",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpCopyLogical",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpPtrEqual: {
-    static InstructionInfo result = {
-        "OpPtrEqual",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpPtrEqual",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpPtrNotEqual: {
-    static InstructionInfo result = {
-        "OpPtrNotEqual",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpPtrNotEqual",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   case spv::Op::OpPtrDiff: {
-    static InstructionInfo result = {
-        "OpPtrDiff",
-        InstructionFlags::HasResult | InstructionFlags::HasResultType,
-        {}};
+    static InstructionInfo result = {"OpPtrDiff",
+                                     InstructionFlags::HasResult |
+                                         InstructionFlags::HasResultType,
+                                     {}};
     return &result;
   }
   }
@@ -2355,8 +2349,7 @@ inline void dump(std::span<const std::uint32_t> range,
       }
 
       if (word >= wordEnd) {
-        if (op == OperandKind::VariadicWord ||
-            op == OperandKind::VariadicId) {
+        if (op == OperandKind::VariadicWord || op == OperandKind::VariadicId) {
           break;
         }
 
@@ -2372,11 +2365,10 @@ inline void dump(std::span<const std::uint32_t> range,
         std::printf(", ");
       }
 
-      if (op == OperandKind::VariadicId ||
-          op == OperandKind::TypeId || op == OperandKind::ValueId) {
+      if (op == OperandKind::VariadicId || op == OperandKind::TypeId ||
+          op == OperandKind::ValueId) {
         printId(currentWord);
-      } else if (op == OperandKind::Word ||
-                 op == OperandKind::VariadicWord) {
+      } else if (op == OperandKind::Word || op == OperandKind::VariadicWord) {
         std::printf("%u", currentWord);
       } else if (op == OperandKind::String) {
         bool foundEnd = false;
diff --git a/hw/amdgpu/lib/libspirv/include/spirv/spirv.hpp b/hw/amdgpu/lib/libspirv/include/spirv/spirv.hpp
index 561c1a8d6..242b2e093 100644
--- a/hw/amdgpu/lib/libspirv/include/spirv/spirv.hpp
+++ b/hw/amdgpu/lib/libspirv/include/spirv/spirv.hpp
@@ -1,19 +1,19 @@
 // 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/ 
-// 
+// 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
@@ -27,18 +27,21 @@
 
 // Enumeration tokens for SPIR-V, in various styles:
 //   C, C++, C++11, JSON, Lua, Python, C#, D, Beef
-// 
+//
 // - 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
+// - 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,
+// - 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
-// - Beef will use enum classes in the Specification class located in the "Spv" namespace,
+// - Beef will use enum classes in the Specification class located in the "Spv"
+// namespace,
 //     e.g.: Spv.Specification.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
@@ -61,1933 +64,1934 @@ static const unsigned int OpCodeMask = 0xffff;
 static const unsigned int WordCountShift = 16;
 
 enum class SourceLanguage : unsigned {
-    Unknown = 0,
-    ESSL = 1,
-    GLSL = 2,
-    OpenCL_C = 3,
-    OpenCL_CPP = 4,
-    HLSL = 5,
-    CPP_for_OpenCL = 6,
-    SYCL = 7,
-    HERO_C = 8,
-    Max = 0x7fffffff,
+  Unknown = 0,
+  ESSL = 1,
+  GLSL = 2,
+  OpenCL_C = 3,
+  OpenCL_CPP = 4,
+  HLSL = 5,
+  CPP_for_OpenCL = 6,
+  SYCL = 7,
+  HERO_C = 8,
+  Max = 0x7fffffff,
 };
 
 enum class ExecutionModel : unsigned {
-    Vertex = 0,
-    TessellationControl = 1,
-    TessellationEvaluation = 2,
-    Geometry = 3,
-    Fragment = 4,
-    GLCompute = 5,
-    Kernel = 6,
-    TaskNV = 5267,
-    MeshNV = 5268,
-    RayGenerationKHR = 5313,
-    RayGenerationNV = 5313,
-    IntersectionKHR = 5314,
-    IntersectionNV = 5314,
-    AnyHitKHR = 5315,
-    AnyHitNV = 5315,
-    ClosestHitKHR = 5316,
-    ClosestHitNV = 5316,
-    MissKHR = 5317,
-    MissNV = 5317,
-    CallableKHR = 5318,
-    CallableNV = 5318,
-    TaskEXT = 5364,
-    MeshEXT = 5365,
-    Max = 0x7fffffff,
+  Vertex = 0,
+  TessellationControl = 1,
+  TessellationEvaluation = 2,
+  Geometry = 3,
+  Fragment = 4,
+  GLCompute = 5,
+  Kernel = 6,
+  TaskNV = 5267,
+  MeshNV = 5268,
+  RayGenerationKHR = 5313,
+  RayGenerationNV = 5313,
+  IntersectionKHR = 5314,
+  IntersectionNV = 5314,
+  AnyHitKHR = 5315,
+  AnyHitNV = 5315,
+  ClosestHitKHR = 5316,
+  ClosestHitNV = 5316,
+  MissKHR = 5317,
+  MissNV = 5317,
+  CallableKHR = 5318,
+  CallableNV = 5318,
+  TaskEXT = 5364,
+  MeshEXT = 5365,
+  Max = 0x7fffffff,
 };
 
 enum class AddressingModel : unsigned {
-    Logical = 0,
-    Physical32 = 1,
-    Physical64 = 2,
-    PhysicalStorageBuffer64 = 5348,
-    PhysicalStorageBuffer64EXT = 5348,
-    Max = 0x7fffffff,
+  Logical = 0,
+  Physical32 = 1,
+  Physical64 = 2,
+  PhysicalStorageBuffer64 = 5348,
+  PhysicalStorageBuffer64EXT = 5348,
+  Max = 0x7fffffff,
 };
 
 enum class MemoryModel : unsigned {
-    Simple = 0,
-    GLSL450 = 1,
-    OpenCL = 2,
-    Vulkan = 3,
-    VulkanKHR = 3,
-    Max = 0x7fffffff,
+  Simple = 0,
+  GLSL450 = 1,
+  OpenCL = 2,
+  Vulkan = 3,
+  VulkanKHR = 3,
+  Max = 0x7fffffff,
 };
 
 enum class ExecutionMode : unsigned {
-    Invocations = 0,
-    SpacingEqual = 1,
-    SpacingFractionalEven = 2,
-    SpacingFractionalOdd = 3,
-    VertexOrderCw = 4,
-    VertexOrderCcw = 5,
-    PixelCenterInteger = 6,
-    OriginUpperLeft = 7,
-    OriginLowerLeft = 8,
-    EarlyFragmentTests = 9,
-    PointMode = 10,
-    Xfb = 11,
-    DepthReplacing = 12,
-    DepthGreater = 14,
-    DepthLess = 15,
-    DepthUnchanged = 16,
-    LocalSize = 17,
-    LocalSizeHint = 18,
-    InputPoints = 19,
-    InputLines = 20,
-    InputLinesAdjacency = 21,
-    Triangles = 22,
-    InputTrianglesAdjacency = 23,
-    Quads = 24,
-    Isolines = 25,
-    OutputVertices = 26,
-    OutputPoints = 27,
-    OutputLineStrip = 28,
-    OutputTriangleStrip = 29,
-    VecTypeHint = 30,
-    ContractionOff = 31,
-    Initializer = 33,
-    Finalizer = 34,
-    SubgroupSize = 35,
-    SubgroupsPerWorkgroup = 36,
-    SubgroupsPerWorkgroupId = 37,
-    LocalSizeId = 38,
-    LocalSizeHintId = 39,
-    NonCoherentColorAttachmentReadEXT = 4169,
-    NonCoherentDepthAttachmentReadEXT = 4170,
-    NonCoherentStencilAttachmentReadEXT = 4171,
-    SubgroupUniformControlFlowKHR = 4421,
-    PostDepthCoverage = 4446,
-    DenormPreserve = 4459,
-    DenormFlushToZero = 4460,
-    SignedZeroInfNanPreserve = 4461,
-    RoundingModeRTE = 4462,
-    RoundingModeRTZ = 4463,
-    EarlyAndLateFragmentTestsAMD = 5017,
-    StencilRefReplacingEXT = 5027,
-    StencilRefUnchangedFrontAMD = 5079,
-    StencilRefGreaterFrontAMD = 5080,
-    StencilRefLessFrontAMD = 5081,
-    StencilRefUnchangedBackAMD = 5082,
-    StencilRefGreaterBackAMD = 5083,
-    StencilRefLessBackAMD = 5084,
-    OutputLinesEXT = 5269,
-    OutputLinesNV = 5269,
-    OutputPrimitivesEXT = 5270,
-    OutputPrimitivesNV = 5270,
-    DerivativeGroupQuadsNV = 5289,
-    DerivativeGroupLinearNV = 5290,
-    OutputTrianglesEXT = 5298,
-    OutputTrianglesNV = 5298,
-    PixelInterlockOrderedEXT = 5366,
-    PixelInterlockUnorderedEXT = 5367,
-    SampleInterlockOrderedEXT = 5368,
-    SampleInterlockUnorderedEXT = 5369,
-    ShadingRateInterlockOrderedEXT = 5370,
-    ShadingRateInterlockUnorderedEXT = 5371,
-    SharedLocalMemorySizeINTEL = 5618,
-    RoundingModeRTPINTEL = 5620,
-    RoundingModeRTNINTEL = 5621,
-    FloatingPointModeALTINTEL = 5622,
-    FloatingPointModeIEEEINTEL = 5623,
-    MaxWorkgroupSizeINTEL = 5893,
-    MaxWorkDimINTEL = 5894,
-    NoGlobalOffsetINTEL = 5895,
-    NumSIMDWorkitemsINTEL = 5896,
-    SchedulerTargetFmaxMhzINTEL = 5903,
-    StreamingInterfaceINTEL = 6154,
-    RegisterMapInterfaceINTEL = 6160,
-    NamedBarrierCountINTEL = 6417,
-    Max = 0x7fffffff,
+  Invocations = 0,
+  SpacingEqual = 1,
+  SpacingFractionalEven = 2,
+  SpacingFractionalOdd = 3,
+  VertexOrderCw = 4,
+  VertexOrderCcw = 5,
+  PixelCenterInteger = 6,
+  OriginUpperLeft = 7,
+  OriginLowerLeft = 8,
+  EarlyFragmentTests = 9,
+  PointMode = 10,
+  Xfb = 11,
+  DepthReplacing = 12,
+  DepthGreater = 14,
+  DepthLess = 15,
+  DepthUnchanged = 16,
+  LocalSize = 17,
+  LocalSizeHint = 18,
+  InputPoints = 19,
+  InputLines = 20,
+  InputLinesAdjacency = 21,
+  Triangles = 22,
+  InputTrianglesAdjacency = 23,
+  Quads = 24,
+  Isolines = 25,
+  OutputVertices = 26,
+  OutputPoints = 27,
+  OutputLineStrip = 28,
+  OutputTriangleStrip = 29,
+  VecTypeHint = 30,
+  ContractionOff = 31,
+  Initializer = 33,
+  Finalizer = 34,
+  SubgroupSize = 35,
+  SubgroupsPerWorkgroup = 36,
+  SubgroupsPerWorkgroupId = 37,
+  LocalSizeId = 38,
+  LocalSizeHintId = 39,
+  NonCoherentColorAttachmentReadEXT = 4169,
+  NonCoherentDepthAttachmentReadEXT = 4170,
+  NonCoherentStencilAttachmentReadEXT = 4171,
+  SubgroupUniformControlFlowKHR = 4421,
+  PostDepthCoverage = 4446,
+  DenormPreserve = 4459,
+  DenormFlushToZero = 4460,
+  SignedZeroInfNanPreserve = 4461,
+  RoundingModeRTE = 4462,
+  RoundingModeRTZ = 4463,
+  EarlyAndLateFragmentTestsAMD = 5017,
+  StencilRefReplacingEXT = 5027,
+  StencilRefUnchangedFrontAMD = 5079,
+  StencilRefGreaterFrontAMD = 5080,
+  StencilRefLessFrontAMD = 5081,
+  StencilRefUnchangedBackAMD = 5082,
+  StencilRefGreaterBackAMD = 5083,
+  StencilRefLessBackAMD = 5084,
+  OutputLinesEXT = 5269,
+  OutputLinesNV = 5269,
+  OutputPrimitivesEXT = 5270,
+  OutputPrimitivesNV = 5270,
+  DerivativeGroupQuadsNV = 5289,
+  DerivativeGroupLinearNV = 5290,
+  OutputTrianglesEXT = 5298,
+  OutputTrianglesNV = 5298,
+  PixelInterlockOrderedEXT = 5366,
+  PixelInterlockUnorderedEXT = 5367,
+  SampleInterlockOrderedEXT = 5368,
+  SampleInterlockUnorderedEXT = 5369,
+  ShadingRateInterlockOrderedEXT = 5370,
+  ShadingRateInterlockUnorderedEXT = 5371,
+  SharedLocalMemorySizeINTEL = 5618,
+  RoundingModeRTPINTEL = 5620,
+  RoundingModeRTNINTEL = 5621,
+  FloatingPointModeALTINTEL = 5622,
+  FloatingPointModeIEEEINTEL = 5623,
+  MaxWorkgroupSizeINTEL = 5893,
+  MaxWorkDimINTEL = 5894,
+  NoGlobalOffsetINTEL = 5895,
+  NumSIMDWorkitemsINTEL = 5896,
+  SchedulerTargetFmaxMhzINTEL = 5903,
+  StreamingInterfaceINTEL = 6154,
+  RegisterMapInterfaceINTEL = 6160,
+  NamedBarrierCountINTEL = 6417,
+  Max = 0x7fffffff,
 };
 
 enum class StorageClass : unsigned {
-    UniformConstant = 0,
-    Input = 1,
-    Uniform = 2,
-    Output = 3,
-    Workgroup = 4,
-    CrossWorkgroup = 5,
-    Private = 6,
-    Function = 7,
-    Generic = 8,
-    PushConstant = 9,
-    AtomicCounter = 10,
-    Image = 11,
-    StorageBuffer = 12,
-    TileImageEXT = 4172,
-    CallableDataKHR = 5328,
-    CallableDataNV = 5328,
-    IncomingCallableDataKHR = 5329,
-    IncomingCallableDataNV = 5329,
-    RayPayloadKHR = 5338,
-    RayPayloadNV = 5338,
-    HitAttributeKHR = 5339,
-    HitAttributeNV = 5339,
-    IncomingRayPayloadKHR = 5342,
-    IncomingRayPayloadNV = 5342,
-    ShaderRecordBufferKHR = 5343,
-    ShaderRecordBufferNV = 5343,
-    PhysicalStorageBuffer = 5349,
-    PhysicalStorageBufferEXT = 5349,
-    HitObjectAttributeNV = 5385,
-    TaskPayloadWorkgroupEXT = 5402,
-    CodeSectionINTEL = 5605,
-    DeviceOnlyINTEL = 5936,
-    HostOnlyINTEL = 5937,
-    Max = 0x7fffffff,
+  UniformConstant = 0,
+  Input = 1,
+  Uniform = 2,
+  Output = 3,
+  Workgroup = 4,
+  CrossWorkgroup = 5,
+  Private = 6,
+  Function = 7,
+  Generic = 8,
+  PushConstant = 9,
+  AtomicCounter = 10,
+  Image = 11,
+  StorageBuffer = 12,
+  TileImageEXT = 4172,
+  CallableDataKHR = 5328,
+  CallableDataNV = 5328,
+  IncomingCallableDataKHR = 5329,
+  IncomingCallableDataNV = 5329,
+  RayPayloadKHR = 5338,
+  RayPayloadNV = 5338,
+  HitAttributeKHR = 5339,
+  HitAttributeNV = 5339,
+  IncomingRayPayloadKHR = 5342,
+  IncomingRayPayloadNV = 5342,
+  ShaderRecordBufferKHR = 5343,
+  ShaderRecordBufferNV = 5343,
+  PhysicalStorageBuffer = 5349,
+  PhysicalStorageBufferEXT = 5349,
+  HitObjectAttributeNV = 5385,
+  TaskPayloadWorkgroupEXT = 5402,
+  CodeSectionINTEL = 5605,
+  DeviceOnlyINTEL = 5936,
+  HostOnlyINTEL = 5937,
+  Max = 0x7fffffff,
 };
 
 enum class Dim : unsigned {
-    Dim1D = 0,
-    Dim2D = 1,
-    Dim3D = 2,
-    Cube = 3,
-    Rect = 4,
-    Buffer = 5,
-    SubpassData = 6,
-    TileImageDataEXT = 4173,
-    Max = 0x7fffffff,
+  Dim1D = 0,
+  Dim2D = 1,
+  Dim3D = 2,
+  Cube = 3,
+  Rect = 4,
+  Buffer = 5,
+  SubpassData = 6,
+  TileImageDataEXT = 4173,
+  Max = 0x7fffffff,
 };
 
 enum class SamplerAddressingMode : unsigned {
-    None = 0,
-    ClampToEdge = 1,
-    Clamp = 2,
-    Repeat = 3,
-    RepeatMirrored = 4,
-    Max = 0x7fffffff,
+  None = 0,
+  ClampToEdge = 1,
+  Clamp = 2,
+  Repeat = 3,
+  RepeatMirrored = 4,
+  Max = 0x7fffffff,
 };
 
 enum class SamplerFilterMode : unsigned {
-    Nearest = 0,
-    Linear = 1,
-    Max = 0x7fffffff,
+  Nearest = 0,
+  Linear = 1,
+  Max = 0x7fffffff,
 };
 
 enum class ImageFormat : unsigned {
-    Unknown = 0,
-    Rgba32f = 1,
-    Rgba16f = 2,
-    R32f = 3,
-    Rgba8 = 4,
-    Rgba8Snorm = 5,
-    Rg32f = 6,
-    Rg16f = 7,
-    R11fG11fB10f = 8,
-    R16f = 9,
-    Rgba16 = 10,
-    Rgb10A2 = 11,
-    Rg16 = 12,
-    Rg8 = 13,
-    R16 = 14,
-    R8 = 15,
-    Rgba16Snorm = 16,
-    Rg16Snorm = 17,
-    Rg8Snorm = 18,
-    R16Snorm = 19,
-    R8Snorm = 20,
-    Rgba32i = 21,
-    Rgba16i = 22,
-    Rgba8i = 23,
-    R32i = 24,
-    Rg32i = 25,
-    Rg16i = 26,
-    Rg8i = 27,
-    R16i = 28,
-    R8i = 29,
-    Rgba32ui = 30,
-    Rgba16ui = 31,
-    Rgba8ui = 32,
-    R32ui = 33,
-    Rgb10a2ui = 34,
-    Rg32ui = 35,
-    Rg16ui = 36,
-    Rg8ui = 37,
-    R16ui = 38,
-    R8ui = 39,
-    R64ui = 40,
-    R64i = 41,
-    Max = 0x7fffffff,
+  Unknown = 0,
+  Rgba32f = 1,
+  Rgba16f = 2,
+  R32f = 3,
+  Rgba8 = 4,
+  Rgba8Snorm = 5,
+  Rg32f = 6,
+  Rg16f = 7,
+  R11fG11fB10f = 8,
+  R16f = 9,
+  Rgba16 = 10,
+  Rgb10A2 = 11,
+  Rg16 = 12,
+  Rg8 = 13,
+  R16 = 14,
+  R8 = 15,
+  Rgba16Snorm = 16,
+  Rg16Snorm = 17,
+  Rg8Snorm = 18,
+  R16Snorm = 19,
+  R8Snorm = 20,
+  Rgba32i = 21,
+  Rgba16i = 22,
+  Rgba8i = 23,
+  R32i = 24,
+  Rg32i = 25,
+  Rg16i = 26,
+  Rg8i = 27,
+  R16i = 28,
+  R8i = 29,
+  Rgba32ui = 30,
+  Rgba16ui = 31,
+  Rgba8ui = 32,
+  R32ui = 33,
+  Rgb10a2ui = 34,
+  Rg32ui = 35,
+  Rg16ui = 36,
+  Rg8ui = 37,
+  R16ui = 38,
+  R8ui = 39,
+  R64ui = 40,
+  R64i = 41,
+  Max = 0x7fffffff,
 };
 
 enum class ImageChannelOrder : unsigned {
-    R = 0,
-    A = 1,
-    RG = 2,
-    RA = 3,
-    RGB = 4,
-    RGBA = 5,
-    BGRA = 6,
-    ARGB = 7,
-    Intensity = 8,
-    Luminance = 9,
-    Rx = 10,
-    RGx = 11,
-    RGBx = 12,
-    Depth = 13,
-    DepthStencil = 14,
-    sRGB = 15,
-    sRGBx = 16,
-    sRGBA = 17,
-    sBGRA = 18,
-    ABGR = 19,
-    Max = 0x7fffffff,
+  R = 0,
+  A = 1,
+  RG = 2,
+  RA = 3,
+  RGB = 4,
+  RGBA = 5,
+  BGRA = 6,
+  ARGB = 7,
+  Intensity = 8,
+  Luminance = 9,
+  Rx = 10,
+  RGx = 11,
+  RGBx = 12,
+  Depth = 13,
+  DepthStencil = 14,
+  sRGB = 15,
+  sRGBx = 16,
+  sRGBA = 17,
+  sBGRA = 18,
+  ABGR = 19,
+  Max = 0x7fffffff,
 };
 
 enum class ImageChannelDataType : unsigned {
-    SnormInt8 = 0,
-    SnormInt16 = 1,
-    UnormInt8 = 2,
-    UnormInt16 = 3,
-    UnormShort565 = 4,
-    UnormShort555 = 5,
-    UnormInt101010 = 6,
-    SignedInt8 = 7,
-    SignedInt16 = 8,
-    SignedInt32 = 9,
-    UnsignedInt8 = 10,
-    UnsignedInt16 = 11,
-    UnsignedInt32 = 12,
-    HalfFloat = 13,
-    Float = 14,
-    UnormInt24 = 15,
-    UnormInt101010_2 = 16,
-    Max = 0x7fffffff,
+  SnormInt8 = 0,
+  SnormInt16 = 1,
+  UnormInt8 = 2,
+  UnormInt16 = 3,
+  UnormShort565 = 4,
+  UnormShort555 = 5,
+  UnormInt101010 = 6,
+  SignedInt8 = 7,
+  SignedInt16 = 8,
+  SignedInt32 = 9,
+  UnsignedInt8 = 10,
+  UnsignedInt16 = 11,
+  UnsignedInt32 = 12,
+  HalfFloat = 13,
+  Float = 14,
+  UnormInt24 = 15,
+  UnormInt101010_2 = 16,
+  Max = 0x7fffffff,
 };
 
 enum class ImageOperandsShift : unsigned {
-    Bias = 0,
-    Lod = 1,
-    Grad = 2,
-    ConstOffset = 3,
-    Offset = 4,
-    ConstOffsets = 5,
-    Sample = 6,
-    MinLod = 7,
-    MakeTexelAvailable = 8,
-    MakeTexelAvailableKHR = 8,
-    MakeTexelVisible = 9,
-    MakeTexelVisibleKHR = 9,
-    NonPrivateTexel = 10,
-    NonPrivateTexelKHR = 10,
-    VolatileTexel = 11,
-    VolatileTexelKHR = 11,
-    SignExtend = 12,
-    ZeroExtend = 13,
-    Nontemporal = 14,
-    Offsets = 16,
-    Max = 0x7fffffff,
+  Bias = 0,
+  Lod = 1,
+  Grad = 2,
+  ConstOffset = 3,
+  Offset = 4,
+  ConstOffsets = 5,
+  Sample = 6,
+  MinLod = 7,
+  MakeTexelAvailable = 8,
+  MakeTexelAvailableKHR = 8,
+  MakeTexelVisible = 9,
+  MakeTexelVisibleKHR = 9,
+  NonPrivateTexel = 10,
+  NonPrivateTexelKHR = 10,
+  VolatileTexel = 11,
+  VolatileTexelKHR = 11,
+  SignExtend = 12,
+  ZeroExtend = 13,
+  Nontemporal = 14,
+  Offsets = 16,
+  Max = 0x7fffffff,
 };
 
 enum class ImageOperandsMask : unsigned {
-    MaskNone = 0,
-    Bias = 0x00000001,
-    Lod = 0x00000002,
-    Grad = 0x00000004,
-    ConstOffset = 0x00000008,
-    Offset = 0x00000010,
-    ConstOffsets = 0x00000020,
-    Sample = 0x00000040,
-    MinLod = 0x00000080,
-    MakeTexelAvailable = 0x00000100,
-    MakeTexelAvailableKHR = 0x00000100,
-    MakeTexelVisible = 0x00000200,
-    MakeTexelVisibleKHR = 0x00000200,
-    NonPrivateTexel = 0x00000400,
-    NonPrivateTexelKHR = 0x00000400,
-    VolatileTexel = 0x00000800,
-    VolatileTexelKHR = 0x00000800,
-    SignExtend = 0x00001000,
-    ZeroExtend = 0x00002000,
-    Nontemporal = 0x00004000,
-    Offsets = 0x00010000,
+  MaskNone = 0,
+  Bias = 0x00000001,
+  Lod = 0x00000002,
+  Grad = 0x00000004,
+  ConstOffset = 0x00000008,
+  Offset = 0x00000010,
+  ConstOffsets = 0x00000020,
+  Sample = 0x00000040,
+  MinLod = 0x00000080,
+  MakeTexelAvailable = 0x00000100,
+  MakeTexelAvailableKHR = 0x00000100,
+  MakeTexelVisible = 0x00000200,
+  MakeTexelVisibleKHR = 0x00000200,
+  NonPrivateTexel = 0x00000400,
+  NonPrivateTexelKHR = 0x00000400,
+  VolatileTexel = 0x00000800,
+  VolatileTexelKHR = 0x00000800,
+  SignExtend = 0x00001000,
+  ZeroExtend = 0x00002000,
+  Nontemporal = 0x00004000,
+  Offsets = 0x00010000,
 };
 
 enum class FPFastMathModeShift : unsigned {
-    NotNaN = 0,
-    NotInf = 1,
-    NSZ = 2,
-    AllowRecip = 3,
-    Fast = 4,
-    AllowContractFastINTEL = 16,
-    AllowReassocINTEL = 17,
-    Max = 0x7fffffff,
+  NotNaN = 0,
+  NotInf = 1,
+  NSZ = 2,
+  AllowRecip = 3,
+  Fast = 4,
+  AllowContractFastINTEL = 16,
+  AllowReassocINTEL = 17,
+  Max = 0x7fffffff,
 };
 
 enum class FPFastMathModeMask : unsigned {
-    MaskNone = 0,
-    NotNaN = 0x00000001,
-    NotInf = 0x00000002,
-    NSZ = 0x00000004,
-    AllowRecip = 0x00000008,
-    Fast = 0x00000010,
-    AllowContractFastINTEL = 0x00010000,
-    AllowReassocINTEL = 0x00020000,
+  MaskNone = 0,
+  NotNaN = 0x00000001,
+  NotInf = 0x00000002,
+  NSZ = 0x00000004,
+  AllowRecip = 0x00000008,
+  Fast = 0x00000010,
+  AllowContractFastINTEL = 0x00010000,
+  AllowReassocINTEL = 0x00020000,
 };
 
 enum class FPRoundingMode : unsigned {
-    RTE = 0,
-    RTZ = 1,
-    RTP = 2,
-    RTN = 3,
-    Max = 0x7fffffff,
+  RTE = 0,
+  RTZ = 1,
+  RTP = 2,
+  RTN = 3,
+  Max = 0x7fffffff,
 };
 
 enum class LinkageType : unsigned {
-    Export = 0,
-    Import = 1,
-    LinkOnceODR = 2,
-    Max = 0x7fffffff,
+  Export = 0,
+  Import = 1,
+  LinkOnceODR = 2,
+  Max = 0x7fffffff,
 };
 
 enum class AccessQualifier : unsigned {
-    ReadOnly = 0,
-    WriteOnly = 1,
-    ReadWrite = 2,
-    Max = 0x7fffffff,
+  ReadOnly = 0,
+  WriteOnly = 1,
+  ReadWrite = 2,
+  Max = 0x7fffffff,
 };
 
 enum class FunctionParameterAttribute : unsigned {
-    Zext = 0,
-    Sext = 1,
-    ByVal = 2,
-    Sret = 3,
-    NoAlias = 4,
-    NoCapture = 5,
-    NoWrite = 6,
-    NoReadWrite = 7,
-    RuntimeAlignedINTEL = 5940,
-    Max = 0x7fffffff,
+  Zext = 0,
+  Sext = 1,
+  ByVal = 2,
+  Sret = 3,
+  NoAlias = 4,
+  NoCapture = 5,
+  NoWrite = 6,
+  NoReadWrite = 7,
+  RuntimeAlignedINTEL = 5940,
+  Max = 0x7fffffff,
 };
 
 enum class Decoration : unsigned {
-    RelaxedPrecision = 0,
-    SpecId = 1,
-    Block = 2,
-    BufferBlock = 3,
-    RowMajor = 4,
-    ColMajor = 5,
-    ArrayStride = 6,
-    MatrixStride = 7,
-    GLSLShared = 8,
-    GLSLPacked = 9,
-    CPacked = 10,
-    BuiltIn = 11,
-    NoPerspective = 13,
-    Flat = 14,
-    Patch = 15,
-    Centroid = 16,
-    Sample = 17,
-    Invariant = 18,
-    Restrict = 19,
-    Aliased = 20,
-    Volatile = 21,
-    Constant = 22,
-    Coherent = 23,
-    NonWritable = 24,
-    NonReadable = 25,
-    Uniform = 26,
-    UniformId = 27,
-    SaturatedConversion = 28,
-    Stream = 29,
-    Location = 30,
-    Component = 31,
-    Index = 32,
-    Binding = 33,
-    DescriptorSet = 34,
-    Offset = 35,
-    XfbBuffer = 36,
-    XfbStride = 37,
-    FuncParamAttr = 38,
-    FPRoundingMode = 39,
-    FPFastMathMode = 40,
-    LinkageAttributes = 41,
-    NoContraction = 42,
-    InputAttachmentIndex = 43,
-    Alignment = 44,
-    MaxByteOffset = 45,
-    AlignmentId = 46,
-    MaxByteOffsetId = 47,
-    NoSignedWrap = 4469,
-    NoUnsignedWrap = 4470,
-    WeightTextureQCOM = 4487,
-    BlockMatchTextureQCOM = 4488,
-    ExplicitInterpAMD = 4999,
-    OverrideCoverageNV = 5248,
-    PassthroughNV = 5250,
-    ViewportRelativeNV = 5252,
-    SecondaryViewportRelativeNV = 5256,
-    PerPrimitiveEXT = 5271,
-    PerPrimitiveNV = 5271,
-    PerViewNV = 5272,
-    PerTaskNV = 5273,
-    PerVertexKHR = 5285,
-    PerVertexNV = 5285,
-    NonUniform = 5300,
-    NonUniformEXT = 5300,
-    RestrictPointer = 5355,
-    RestrictPointerEXT = 5355,
-    AliasedPointer = 5356,
-    AliasedPointerEXT = 5356,
-    HitObjectShaderRecordBufferNV = 5386,
-    BindlessSamplerNV = 5398,
-    BindlessImageNV = 5399,
-    BoundSamplerNV = 5400,
-    BoundImageNV = 5401,
-    SIMTCallINTEL = 5599,
-    ReferencedIndirectlyINTEL = 5602,
-    ClobberINTEL = 5607,
-    SideEffectsINTEL = 5608,
-    VectorComputeVariableINTEL = 5624,
-    FuncParamIOKindINTEL = 5625,
-    VectorComputeFunctionINTEL = 5626,
-    StackCallINTEL = 5627,
-    GlobalVariableOffsetINTEL = 5628,
-    CounterBuffer = 5634,
-    HlslCounterBufferGOOGLE = 5634,
-    HlslSemanticGOOGLE = 5635,
-    UserSemantic = 5635,
-    UserTypeGOOGLE = 5636,
-    FunctionRoundingModeINTEL = 5822,
-    FunctionDenormModeINTEL = 5823,
-    RegisterINTEL = 5825,
-    MemoryINTEL = 5826,
-    NumbanksINTEL = 5827,
-    BankwidthINTEL = 5828,
-    MaxPrivateCopiesINTEL = 5829,
-    SinglepumpINTEL = 5830,
-    DoublepumpINTEL = 5831,
-    MaxReplicatesINTEL = 5832,
-    SimpleDualPortINTEL = 5833,
-    MergeINTEL = 5834,
-    BankBitsINTEL = 5835,
-    ForcePow2DepthINTEL = 5836,
-    BurstCoalesceINTEL = 5899,
-    CacheSizeINTEL = 5900,
-    DontStaticallyCoalesceINTEL = 5901,
-    PrefetchINTEL = 5902,
-    StallEnableINTEL = 5905,
-    FuseLoopsInFunctionINTEL = 5907,
-    MathOpDSPModeINTEL = 5909,
-    AliasScopeINTEL = 5914,
-    NoAliasINTEL = 5915,
-    InitiationIntervalINTEL = 5917,
-    MaxConcurrencyINTEL = 5918,
-    PipelineEnableINTEL = 5919,
-    BufferLocationINTEL = 5921,
-    IOPipeStorageINTEL = 5944,
-    FunctionFloatingPointModeINTEL = 6080,
-    SingleElementVectorINTEL = 6085,
-    VectorComputeCallableFunctionINTEL = 6087,
-    MediaBlockIOINTEL = 6140,
-    LatencyControlLabelINTEL = 6172,
-    LatencyControlConstraintINTEL = 6173,
-    ConduitKernelArgumentINTEL = 6175,
-    RegisterMapKernelArgumentINTEL = 6176,
-    MMHostInterfaceAddressWidthINTEL = 6177,
-    MMHostInterfaceDataWidthINTEL = 6178,
-    MMHostInterfaceLatencyINTEL = 6179,
-    MMHostInterfaceReadWriteModeINTEL = 6180,
-    MMHostInterfaceMaxBurstINTEL = 6181,
-    MMHostInterfaceWaitRequestINTEL = 6182,
-    StableKernelArgumentINTEL = 6183,
-    Max = 0x7fffffff,
+  RelaxedPrecision = 0,
+  SpecId = 1,
+  Block = 2,
+  BufferBlock = 3,
+  RowMajor = 4,
+  ColMajor = 5,
+  ArrayStride = 6,
+  MatrixStride = 7,
+  GLSLShared = 8,
+  GLSLPacked = 9,
+  CPacked = 10,
+  BuiltIn = 11,
+  NoPerspective = 13,
+  Flat = 14,
+  Patch = 15,
+  Centroid = 16,
+  Sample = 17,
+  Invariant = 18,
+  Restrict = 19,
+  Aliased = 20,
+  Volatile = 21,
+  Constant = 22,
+  Coherent = 23,
+  NonWritable = 24,
+  NonReadable = 25,
+  Uniform = 26,
+  UniformId = 27,
+  SaturatedConversion = 28,
+  Stream = 29,
+  Location = 30,
+  Component = 31,
+  Index = 32,
+  Binding = 33,
+  DescriptorSet = 34,
+  Offset = 35,
+  XfbBuffer = 36,
+  XfbStride = 37,
+  FuncParamAttr = 38,
+  FPRoundingMode = 39,
+  FPFastMathMode = 40,
+  LinkageAttributes = 41,
+  NoContraction = 42,
+  InputAttachmentIndex = 43,
+  Alignment = 44,
+  MaxByteOffset = 45,
+  AlignmentId = 46,
+  MaxByteOffsetId = 47,
+  NoSignedWrap = 4469,
+  NoUnsignedWrap = 4470,
+  WeightTextureQCOM = 4487,
+  BlockMatchTextureQCOM = 4488,
+  ExplicitInterpAMD = 4999,
+  OverrideCoverageNV = 5248,
+  PassthroughNV = 5250,
+  ViewportRelativeNV = 5252,
+  SecondaryViewportRelativeNV = 5256,
+  PerPrimitiveEXT = 5271,
+  PerPrimitiveNV = 5271,
+  PerViewNV = 5272,
+  PerTaskNV = 5273,
+  PerVertexKHR = 5285,
+  PerVertexNV = 5285,
+  NonUniform = 5300,
+  NonUniformEXT = 5300,
+  RestrictPointer = 5355,
+  RestrictPointerEXT = 5355,
+  AliasedPointer = 5356,
+  AliasedPointerEXT = 5356,
+  HitObjectShaderRecordBufferNV = 5386,
+  BindlessSamplerNV = 5398,
+  BindlessImageNV = 5399,
+  BoundSamplerNV = 5400,
+  BoundImageNV = 5401,
+  SIMTCallINTEL = 5599,
+  ReferencedIndirectlyINTEL = 5602,
+  ClobberINTEL = 5607,
+  SideEffectsINTEL = 5608,
+  VectorComputeVariableINTEL = 5624,
+  FuncParamIOKindINTEL = 5625,
+  VectorComputeFunctionINTEL = 5626,
+  StackCallINTEL = 5627,
+  GlobalVariableOffsetINTEL = 5628,
+  CounterBuffer = 5634,
+  HlslCounterBufferGOOGLE = 5634,
+  HlslSemanticGOOGLE = 5635,
+  UserSemantic = 5635,
+  UserTypeGOOGLE = 5636,
+  FunctionRoundingModeINTEL = 5822,
+  FunctionDenormModeINTEL = 5823,
+  RegisterINTEL = 5825,
+  MemoryINTEL = 5826,
+  NumbanksINTEL = 5827,
+  BankwidthINTEL = 5828,
+  MaxPrivateCopiesINTEL = 5829,
+  SinglepumpINTEL = 5830,
+  DoublepumpINTEL = 5831,
+  MaxReplicatesINTEL = 5832,
+  SimpleDualPortINTEL = 5833,
+  MergeINTEL = 5834,
+  BankBitsINTEL = 5835,
+  ForcePow2DepthINTEL = 5836,
+  BurstCoalesceINTEL = 5899,
+  CacheSizeINTEL = 5900,
+  DontStaticallyCoalesceINTEL = 5901,
+  PrefetchINTEL = 5902,
+  StallEnableINTEL = 5905,
+  FuseLoopsInFunctionINTEL = 5907,
+  MathOpDSPModeINTEL = 5909,
+  AliasScopeINTEL = 5914,
+  NoAliasINTEL = 5915,
+  InitiationIntervalINTEL = 5917,
+  MaxConcurrencyINTEL = 5918,
+  PipelineEnableINTEL = 5919,
+  BufferLocationINTEL = 5921,
+  IOPipeStorageINTEL = 5944,
+  FunctionFloatingPointModeINTEL = 6080,
+  SingleElementVectorINTEL = 6085,
+  VectorComputeCallableFunctionINTEL = 6087,
+  MediaBlockIOINTEL = 6140,
+  LatencyControlLabelINTEL = 6172,
+  LatencyControlConstraintINTEL = 6173,
+  ConduitKernelArgumentINTEL = 6175,
+  RegisterMapKernelArgumentINTEL = 6176,
+  MMHostInterfaceAddressWidthINTEL = 6177,
+  MMHostInterfaceDataWidthINTEL = 6178,
+  MMHostInterfaceLatencyINTEL = 6179,
+  MMHostInterfaceReadWriteModeINTEL = 6180,
+  MMHostInterfaceMaxBurstINTEL = 6181,
+  MMHostInterfaceWaitRequestINTEL = 6182,
+  StableKernelArgumentINTEL = 6183,
+  Max = 0x7fffffff,
 };
 
 enum class BuiltIn : unsigned {
-    Position = 0,
-    PointSize = 1,
-    ClipDistance = 3,
-    CullDistance = 4,
-    VertexId = 5,
-    InstanceId = 6,
-    PrimitiveId = 7,
-    InvocationId = 8,
-    Layer = 9,
-    ViewportIndex = 10,
-    TessLevelOuter = 11,
-    TessLevelInner = 12,
-    TessCoord = 13,
-    PatchVertices = 14,
-    FragCoord = 15,
-    PointCoord = 16,
-    FrontFacing = 17,
-    SampleId = 18,
-    SamplePosition = 19,
-    SampleMask = 20,
-    FragDepth = 22,
-    HelperInvocation = 23,
-    NumWorkgroups = 24,
-    WorkgroupSize = 25,
-    WorkgroupId = 26,
-    LocalInvocationId = 27,
-    GlobalInvocationId = 28,
-    LocalInvocationIndex = 29,
-    WorkDim = 30,
-    GlobalSize = 31,
-    EnqueuedWorkgroupSize = 32,
-    GlobalOffset = 33,
-    GlobalLinearId = 34,
-    SubgroupSize = 36,
-    SubgroupMaxSize = 37,
-    NumSubgroups = 38,
-    NumEnqueuedSubgroups = 39,
-    SubgroupId = 40,
-    SubgroupLocalInvocationId = 41,
-    VertexIndex = 42,
-    InstanceIndex = 43,
-    CoreIDARM = 4160,
-    CoreCountARM = 4161,
-    CoreMaxIDARM = 4162,
-    WarpIDARM = 4163,
-    WarpMaxIDARM = 4164,
-    SubgroupEqMask = 4416,
-    SubgroupEqMaskKHR = 4416,
-    SubgroupGeMask = 4417,
-    SubgroupGeMaskKHR = 4417,
-    SubgroupGtMask = 4418,
-    SubgroupGtMaskKHR = 4418,
-    SubgroupLeMask = 4419,
-    SubgroupLeMaskKHR = 4419,
-    SubgroupLtMask = 4420,
-    SubgroupLtMaskKHR = 4420,
-    BaseVertex = 4424,
-    BaseInstance = 4425,
-    DrawIndex = 4426,
-    PrimitiveShadingRateKHR = 4432,
-    DeviceIndex = 4438,
-    ViewIndex = 4440,
-    ShadingRateKHR = 4444,
-    BaryCoordNoPerspAMD = 4992,
-    BaryCoordNoPerspCentroidAMD = 4993,
-    BaryCoordNoPerspSampleAMD = 4994,
-    BaryCoordSmoothAMD = 4995,
-    BaryCoordSmoothCentroidAMD = 4996,
-    BaryCoordSmoothSampleAMD = 4997,
-    BaryCoordPullModelAMD = 4998,
-    FragStencilRefEXT = 5014,
-    ViewportMaskNV = 5253,
-    SecondaryPositionNV = 5257,
-    SecondaryViewportMaskNV = 5258,
-    PositionPerViewNV = 5261,
-    ViewportMaskPerViewNV = 5262,
-    FullyCoveredEXT = 5264,
-    TaskCountNV = 5274,
-    PrimitiveCountNV = 5275,
-    PrimitiveIndicesNV = 5276,
-    ClipDistancePerViewNV = 5277,
-    CullDistancePerViewNV = 5278,
-    LayerPerViewNV = 5279,
-    MeshViewCountNV = 5280,
-    MeshViewIndicesNV = 5281,
-    BaryCoordKHR = 5286,
-    BaryCoordNV = 5286,
-    BaryCoordNoPerspKHR = 5287,
-    BaryCoordNoPerspNV = 5287,
-    FragSizeEXT = 5292,
-    FragmentSizeNV = 5292,
-    FragInvocationCountEXT = 5293,
-    InvocationsPerPixelNV = 5293,
-    PrimitivePointIndicesEXT = 5294,
-    PrimitiveLineIndicesEXT = 5295,
-    PrimitiveTriangleIndicesEXT = 5296,
-    CullPrimitiveEXT = 5299,
-    LaunchIdKHR = 5319,
-    LaunchIdNV = 5319,
-    LaunchSizeKHR = 5320,
-    LaunchSizeNV = 5320,
-    WorldRayOriginKHR = 5321,
-    WorldRayOriginNV = 5321,
-    WorldRayDirectionKHR = 5322,
-    WorldRayDirectionNV = 5322,
-    ObjectRayOriginKHR = 5323,
-    ObjectRayOriginNV = 5323,
-    ObjectRayDirectionKHR = 5324,
-    ObjectRayDirectionNV = 5324,
-    RayTminKHR = 5325,
-    RayTminNV = 5325,
-    RayTmaxKHR = 5326,
-    RayTmaxNV = 5326,
-    InstanceCustomIndexKHR = 5327,
-    InstanceCustomIndexNV = 5327,
-    ObjectToWorldKHR = 5330,
-    ObjectToWorldNV = 5330,
-    WorldToObjectKHR = 5331,
-    WorldToObjectNV = 5331,
-    HitTNV = 5332,
-    HitKindKHR = 5333,
-    HitKindNV = 5333,
-    CurrentRayTimeNV = 5334,
-    HitTriangleVertexPositionsKHR = 5335,
-    IncomingRayFlagsKHR = 5351,
-    IncomingRayFlagsNV = 5351,
-    RayGeometryIndexKHR = 5352,
-    WarpsPerSMNV = 5374,
-    SMCountNV = 5375,
-    WarpIDNV = 5376,
-    SMIDNV = 5377,
-    CullMaskKHR = 6021,
-    Max = 0x7fffffff,
+  Position = 0,
+  PointSize = 1,
+  ClipDistance = 3,
+  CullDistance = 4,
+  VertexId = 5,
+  InstanceId = 6,
+  PrimitiveId = 7,
+  InvocationId = 8,
+  Layer = 9,
+  ViewportIndex = 10,
+  TessLevelOuter = 11,
+  TessLevelInner = 12,
+  TessCoord = 13,
+  PatchVertices = 14,
+  FragCoord = 15,
+  PointCoord = 16,
+  FrontFacing = 17,
+  SampleId = 18,
+  SamplePosition = 19,
+  SampleMask = 20,
+  FragDepth = 22,
+  HelperInvocation = 23,
+  NumWorkgroups = 24,
+  WorkgroupSize = 25,
+  WorkgroupId = 26,
+  LocalInvocationId = 27,
+  GlobalInvocationId = 28,
+  LocalInvocationIndex = 29,
+  WorkDim = 30,
+  GlobalSize = 31,
+  EnqueuedWorkgroupSize = 32,
+  GlobalOffset = 33,
+  GlobalLinearId = 34,
+  SubgroupSize = 36,
+  SubgroupMaxSize = 37,
+  NumSubgroups = 38,
+  NumEnqueuedSubgroups = 39,
+  SubgroupId = 40,
+  SubgroupLocalInvocationId = 41,
+  VertexIndex = 42,
+  InstanceIndex = 43,
+  CoreIDARM = 4160,
+  CoreCountARM = 4161,
+  CoreMaxIDARM = 4162,
+  WarpIDARM = 4163,
+  WarpMaxIDARM = 4164,
+  SubgroupEqMask = 4416,
+  SubgroupEqMaskKHR = 4416,
+  SubgroupGeMask = 4417,
+  SubgroupGeMaskKHR = 4417,
+  SubgroupGtMask = 4418,
+  SubgroupGtMaskKHR = 4418,
+  SubgroupLeMask = 4419,
+  SubgroupLeMaskKHR = 4419,
+  SubgroupLtMask = 4420,
+  SubgroupLtMaskKHR = 4420,
+  BaseVertex = 4424,
+  BaseInstance = 4425,
+  DrawIndex = 4426,
+  PrimitiveShadingRateKHR = 4432,
+  DeviceIndex = 4438,
+  ViewIndex = 4440,
+  ShadingRateKHR = 4444,
+  BaryCoordNoPerspAMD = 4992,
+  BaryCoordNoPerspCentroidAMD = 4993,
+  BaryCoordNoPerspSampleAMD = 4994,
+  BaryCoordSmoothAMD = 4995,
+  BaryCoordSmoothCentroidAMD = 4996,
+  BaryCoordSmoothSampleAMD = 4997,
+  BaryCoordPullModelAMD = 4998,
+  FragStencilRefEXT = 5014,
+  ViewportMaskNV = 5253,
+  SecondaryPositionNV = 5257,
+  SecondaryViewportMaskNV = 5258,
+  PositionPerViewNV = 5261,
+  ViewportMaskPerViewNV = 5262,
+  FullyCoveredEXT = 5264,
+  TaskCountNV = 5274,
+  PrimitiveCountNV = 5275,
+  PrimitiveIndicesNV = 5276,
+  ClipDistancePerViewNV = 5277,
+  CullDistancePerViewNV = 5278,
+  LayerPerViewNV = 5279,
+  MeshViewCountNV = 5280,
+  MeshViewIndicesNV = 5281,
+  BaryCoordKHR = 5286,
+  BaryCoordNV = 5286,
+  BaryCoordNoPerspKHR = 5287,
+  BaryCoordNoPerspNV = 5287,
+  FragSizeEXT = 5292,
+  FragmentSizeNV = 5292,
+  FragInvocationCountEXT = 5293,
+  InvocationsPerPixelNV = 5293,
+  PrimitivePointIndicesEXT = 5294,
+  PrimitiveLineIndicesEXT = 5295,
+  PrimitiveTriangleIndicesEXT = 5296,
+  CullPrimitiveEXT = 5299,
+  LaunchIdKHR = 5319,
+  LaunchIdNV = 5319,
+  LaunchSizeKHR = 5320,
+  LaunchSizeNV = 5320,
+  WorldRayOriginKHR = 5321,
+  WorldRayOriginNV = 5321,
+  WorldRayDirectionKHR = 5322,
+  WorldRayDirectionNV = 5322,
+  ObjectRayOriginKHR = 5323,
+  ObjectRayOriginNV = 5323,
+  ObjectRayDirectionKHR = 5324,
+  ObjectRayDirectionNV = 5324,
+  RayTminKHR = 5325,
+  RayTminNV = 5325,
+  RayTmaxKHR = 5326,
+  RayTmaxNV = 5326,
+  InstanceCustomIndexKHR = 5327,
+  InstanceCustomIndexNV = 5327,
+  ObjectToWorldKHR = 5330,
+  ObjectToWorldNV = 5330,
+  WorldToObjectKHR = 5331,
+  WorldToObjectNV = 5331,
+  HitTNV = 5332,
+  HitKindKHR = 5333,
+  HitKindNV = 5333,
+  CurrentRayTimeNV = 5334,
+  HitTriangleVertexPositionsKHR = 5335,
+  IncomingRayFlagsKHR = 5351,
+  IncomingRayFlagsNV = 5351,
+  RayGeometryIndexKHR = 5352,
+  WarpsPerSMNV = 5374,
+  SMCountNV = 5375,
+  WarpIDNV = 5376,
+  SMIDNV = 5377,
+  CullMaskKHR = 6021,
+  Max = 0x7fffffff,
 };
 
 enum class SelectionControlShift : unsigned {
-    Flatten = 0,
-    DontFlatten = 1,
-    Max = 0x7fffffff,
+  Flatten = 0,
+  DontFlatten = 1,
+  Max = 0x7fffffff,
 };
 
 enum class SelectionControlMask : unsigned {
-    MaskNone = 0,
-    Flatten = 0x00000001,
-    DontFlatten = 0x00000002,
+  MaskNone = 0,
+  Flatten = 0x00000001,
+  DontFlatten = 0x00000002,
 };
 
 enum class LoopControlShift : unsigned {
-    Unroll = 0,
-    DontUnroll = 1,
-    DependencyInfinite = 2,
-    DependencyLength = 3,
-    MinIterations = 4,
-    MaxIterations = 5,
-    IterationMultiple = 6,
-    PeelCount = 7,
-    PartialCount = 8,
-    InitiationIntervalINTEL = 16,
-    MaxConcurrencyINTEL = 17,
-    DependencyArrayINTEL = 18,
-    PipelineEnableINTEL = 19,
-    LoopCoalesceINTEL = 20,
-    MaxInterleavingINTEL = 21,
-    SpeculatedIterationsINTEL = 22,
-    NoFusionINTEL = 23,
-    LoopCountINTEL = 24,
-    MaxReinvocationDelayINTEL = 25,
-    Max = 0x7fffffff,
+  Unroll = 0,
+  DontUnroll = 1,
+  DependencyInfinite = 2,
+  DependencyLength = 3,
+  MinIterations = 4,
+  MaxIterations = 5,
+  IterationMultiple = 6,
+  PeelCount = 7,
+  PartialCount = 8,
+  InitiationIntervalINTEL = 16,
+  MaxConcurrencyINTEL = 17,
+  DependencyArrayINTEL = 18,
+  PipelineEnableINTEL = 19,
+  LoopCoalesceINTEL = 20,
+  MaxInterleavingINTEL = 21,
+  SpeculatedIterationsINTEL = 22,
+  NoFusionINTEL = 23,
+  LoopCountINTEL = 24,
+  MaxReinvocationDelayINTEL = 25,
+  Max = 0x7fffffff,
 };
 
 enum class LoopControlMask : unsigned {
-    MaskNone = 0,
-    Unroll = 0x00000001,
-    DontUnroll = 0x00000002,
-    DependencyInfinite = 0x00000004,
-    DependencyLength = 0x00000008,
-    MinIterations = 0x00000010,
-    MaxIterations = 0x00000020,
-    IterationMultiple = 0x00000040,
-    PeelCount = 0x00000080,
-    PartialCount = 0x00000100,
-    InitiationIntervalINTEL = 0x00010000,
-    MaxConcurrencyINTEL = 0x00020000,
-    DependencyArrayINTEL = 0x00040000,
-    PipelineEnableINTEL = 0x00080000,
-    LoopCoalesceINTEL = 0x00100000,
-    MaxInterleavingINTEL = 0x00200000,
-    SpeculatedIterationsINTEL = 0x00400000,
-    NoFusionINTEL = 0x00800000,
-    LoopCountINTEL = 0x01000000,
-    MaxReinvocationDelayINTEL = 0x02000000,
+  MaskNone = 0,
+  Unroll = 0x00000001,
+  DontUnroll = 0x00000002,
+  DependencyInfinite = 0x00000004,
+  DependencyLength = 0x00000008,
+  MinIterations = 0x00000010,
+  MaxIterations = 0x00000020,
+  IterationMultiple = 0x00000040,
+  PeelCount = 0x00000080,
+  PartialCount = 0x00000100,
+  InitiationIntervalINTEL = 0x00010000,
+  MaxConcurrencyINTEL = 0x00020000,
+  DependencyArrayINTEL = 0x00040000,
+  PipelineEnableINTEL = 0x00080000,
+  LoopCoalesceINTEL = 0x00100000,
+  MaxInterleavingINTEL = 0x00200000,
+  SpeculatedIterationsINTEL = 0x00400000,
+  NoFusionINTEL = 0x00800000,
+  LoopCountINTEL = 0x01000000,
+  MaxReinvocationDelayINTEL = 0x02000000,
 };
 
 enum class FunctionControlShift : unsigned {
-    Inline = 0,
-    DontInline = 1,
-    Pure = 2,
-    Const = 3,
-    OptNoneINTEL = 16,
-    Max = 0x7fffffff,
+  Inline = 0,
+  DontInline = 1,
+  Pure = 2,
+  Const = 3,
+  OptNoneINTEL = 16,
+  Max = 0x7fffffff,
 };
 
 enum class FunctionControlMask : unsigned {
-    MaskNone = 0,
-    Inline = 0x00000001,
-    DontInline = 0x00000002,
-    Pure = 0x00000004,
-    Const = 0x00000008,
-    OptNoneINTEL = 0x00010000,
+  MaskNone = 0,
+  Inline = 0x00000001,
+  DontInline = 0x00000002,
+  Pure = 0x00000004,
+  Const = 0x00000008,
+  OptNoneINTEL = 0x00010000,
 };
 
 enum class MemorySemanticsShift : unsigned {
-    Acquire = 1,
-    Release = 2,
-    AcquireRelease = 3,
-    SequentiallyConsistent = 4,
-    UniformMemory = 6,
-    SubgroupMemory = 7,
-    WorkgroupMemory = 8,
-    CrossWorkgroupMemory = 9,
-    AtomicCounterMemory = 10,
-    ImageMemory = 11,
-    OutputMemory = 12,
-    OutputMemoryKHR = 12,
-    MakeAvailable = 13,
-    MakeAvailableKHR = 13,
-    MakeVisible = 14,
-    MakeVisibleKHR = 14,
-    Volatile = 15,
-    Max = 0x7fffffff,
+  Acquire = 1,
+  Release = 2,
+  AcquireRelease = 3,
+  SequentiallyConsistent = 4,
+  UniformMemory = 6,
+  SubgroupMemory = 7,
+  WorkgroupMemory = 8,
+  CrossWorkgroupMemory = 9,
+  AtomicCounterMemory = 10,
+  ImageMemory = 11,
+  OutputMemory = 12,
+  OutputMemoryKHR = 12,
+  MakeAvailable = 13,
+  MakeAvailableKHR = 13,
+  MakeVisible = 14,
+  MakeVisibleKHR = 14,
+  Volatile = 15,
+  Max = 0x7fffffff,
 };
 
 enum class MemorySemanticsMask : unsigned {
-    MaskNone = 0,
-    Acquire = 0x00000002,
-    Release = 0x00000004,
-    AcquireRelease = 0x00000008,
-    SequentiallyConsistent = 0x00000010,
-    UniformMemory = 0x00000040,
-    SubgroupMemory = 0x00000080,
-    WorkgroupMemory = 0x00000100,
-    CrossWorkgroupMemory = 0x00000200,
-    AtomicCounterMemory = 0x00000400,
-    ImageMemory = 0x00000800,
-    OutputMemory = 0x00001000,
-    OutputMemoryKHR = 0x00001000,
-    MakeAvailable = 0x00002000,
-    MakeAvailableKHR = 0x00002000,
-    MakeVisible = 0x00004000,
-    MakeVisibleKHR = 0x00004000,
-    Volatile = 0x00008000,
+  MaskNone = 0,
+  Acquire = 0x00000002,
+  Release = 0x00000004,
+  AcquireRelease = 0x00000008,
+  SequentiallyConsistent = 0x00000010,
+  UniformMemory = 0x00000040,
+  SubgroupMemory = 0x00000080,
+  WorkgroupMemory = 0x00000100,
+  CrossWorkgroupMemory = 0x00000200,
+  AtomicCounterMemory = 0x00000400,
+  ImageMemory = 0x00000800,
+  OutputMemory = 0x00001000,
+  OutputMemoryKHR = 0x00001000,
+  MakeAvailable = 0x00002000,
+  MakeAvailableKHR = 0x00002000,
+  MakeVisible = 0x00004000,
+  MakeVisibleKHR = 0x00004000,
+  Volatile = 0x00008000,
 };
 
 enum class MemoryAccessShift : unsigned {
-    Volatile = 0,
-    Aligned = 1,
-    Nontemporal = 2,
-    MakePointerAvailable = 3,
-    MakePointerAvailableKHR = 3,
-    MakePointerVisible = 4,
-    MakePointerVisibleKHR = 4,
-    NonPrivatePointer = 5,
-    NonPrivatePointerKHR = 5,
-    AliasScopeINTELMask = 16,
-    NoAliasINTELMask = 17,
-    Max = 0x7fffffff,
+  Volatile = 0,
+  Aligned = 1,
+  Nontemporal = 2,
+  MakePointerAvailable = 3,
+  MakePointerAvailableKHR = 3,
+  MakePointerVisible = 4,
+  MakePointerVisibleKHR = 4,
+  NonPrivatePointer = 5,
+  NonPrivatePointerKHR = 5,
+  AliasScopeINTELMask = 16,
+  NoAliasINTELMask = 17,
+  Max = 0x7fffffff,
 };
 
 enum class MemoryAccessMask : unsigned {
-    MaskNone = 0,
-    Volatile = 0x00000001,
-    Aligned = 0x00000002,
-    Nontemporal = 0x00000004,
-    MakePointerAvailable = 0x00000008,
-    MakePointerAvailableKHR = 0x00000008,
-    MakePointerVisible = 0x00000010,
-    MakePointerVisibleKHR = 0x00000010,
-    NonPrivatePointer = 0x00000020,
-    NonPrivatePointerKHR = 0x00000020,
-    AliasScopeINTELMask = 0x00010000,
-    NoAliasINTELMask = 0x00020000,
+  MaskNone = 0,
+  Volatile = 0x00000001,
+  Aligned = 0x00000002,
+  Nontemporal = 0x00000004,
+  MakePointerAvailable = 0x00000008,
+  MakePointerAvailableKHR = 0x00000008,
+  MakePointerVisible = 0x00000010,
+  MakePointerVisibleKHR = 0x00000010,
+  NonPrivatePointer = 0x00000020,
+  NonPrivatePointerKHR = 0x00000020,
+  AliasScopeINTELMask = 0x00010000,
+  NoAliasINTELMask = 0x00020000,
 };
 
 enum class Scope : unsigned {
-    CrossDevice = 0,
-    Device = 1,
-    Workgroup = 2,
-    Subgroup = 3,
-    Invocation = 4,
-    QueueFamily = 5,
-    QueueFamilyKHR = 5,
-    ShaderCallKHR = 6,
-    Max = 0x7fffffff,
+  CrossDevice = 0,
+  Device = 1,
+  Workgroup = 2,
+  Subgroup = 3,
+  Invocation = 4,
+  QueueFamily = 5,
+  QueueFamilyKHR = 5,
+  ShaderCallKHR = 6,
+  Max = 0x7fffffff,
 };
 
 enum class GroupOperation : unsigned {
-    Reduce = 0,
-    InclusiveScan = 1,
-    ExclusiveScan = 2,
-    ClusteredReduce = 3,
-    PartitionedReduceNV = 6,
-    PartitionedInclusiveScanNV = 7,
-    PartitionedExclusiveScanNV = 8,
-    Max = 0x7fffffff,
+  Reduce = 0,
+  InclusiveScan = 1,
+  ExclusiveScan = 2,
+  ClusteredReduce = 3,
+  PartitionedReduceNV = 6,
+  PartitionedInclusiveScanNV = 7,
+  PartitionedExclusiveScanNV = 8,
+  Max = 0x7fffffff,
 };
 
 enum class KernelEnqueueFlags : unsigned {
-    NoWait = 0,
-    WaitKernel = 1,
-    WaitWorkGroup = 2,
-    Max = 0x7fffffff,
+  NoWait = 0,
+  WaitKernel = 1,
+  WaitWorkGroup = 2,
+  Max = 0x7fffffff,
 };
 
 enum class KernelProfilingInfoShift : unsigned {
-    CmdExecTime = 0,
-    Max = 0x7fffffff,
+  CmdExecTime = 0,
+  Max = 0x7fffffff,
 };
 
 enum class KernelProfilingInfoMask : unsigned {
-    MaskNone = 0,
-    CmdExecTime = 0x00000001,
+  MaskNone = 0,
+  CmdExecTime = 0x00000001,
 };
 
 enum class Capability : unsigned {
-    Matrix = 0,
-    Shader = 1,
-    Geometry = 2,
-    Tessellation = 3,
-    Addresses = 4,
-    Linkage = 5,
-    Kernel = 6,
-    Vector16 = 7,
-    Float16Buffer = 8,
-    Float16 = 9,
-    Float64 = 10,
-    Int64 = 11,
-    Int64Atomics = 12,
-    ImageBasic = 13,
-    ImageReadWrite = 14,
-    ImageMipmap = 15,
-    Pipes = 17,
-    Groups = 18,
-    DeviceEnqueue = 19,
-    LiteralSampler = 20,
-    AtomicStorage = 21,
-    Int16 = 22,
-    TessellationPointSize = 23,
-    GeometryPointSize = 24,
-    ImageGatherExtended = 25,
-    StorageImageMultisample = 27,
-    UniformBufferArrayDynamicIndexing = 28,
-    SampledImageArrayDynamicIndexing = 29,
-    StorageBufferArrayDynamicIndexing = 30,
-    StorageImageArrayDynamicIndexing = 31,
-    ClipDistance = 32,
-    CullDistance = 33,
-    ImageCubeArray = 34,
-    SampleRateShading = 35,
-    ImageRect = 36,
-    SampledRect = 37,
-    GenericPointer = 38,
-    Int8 = 39,
-    InputAttachment = 40,
-    SparseResidency = 41,
-    MinLod = 42,
-    Sampled1D = 43,
-    Image1D = 44,
-    SampledCubeArray = 45,
-    SampledBuffer = 46,
-    ImageBuffer = 47,
-    ImageMSArray = 48,
-    StorageImageExtendedFormats = 49,
-    ImageQuery = 50,
-    DerivativeControl = 51,
-    InterpolationFunction = 52,
-    TransformFeedback = 53,
-    GeometryStreams = 54,
-    StorageImageReadWithoutFormat = 55,
-    StorageImageWriteWithoutFormat = 56,
-    MultiViewport = 57,
-    SubgroupDispatch = 58,
-    NamedBarrier = 59,
-    PipeStorage = 60,
-    GroupNonUniform = 61,
-    GroupNonUniformVote = 62,
-    GroupNonUniformArithmetic = 63,
-    GroupNonUniformBallot = 64,
-    GroupNonUniformShuffle = 65,
-    GroupNonUniformShuffleRelative = 66,
-    GroupNonUniformClustered = 67,
-    GroupNonUniformQuad = 68,
-    ShaderLayer = 69,
-    ShaderViewportIndex = 70,
-    UniformDecoration = 71,
-    CoreBuiltinsARM = 4165,
-    TileImageColorReadAccessEXT = 4166,
-    TileImageDepthReadAccessEXT = 4167,
-    TileImageStencilReadAccessEXT = 4168,
-    FragmentShadingRateKHR = 4422,
-    SubgroupBallotKHR = 4423,
-    DrawParameters = 4427,
-    WorkgroupMemoryExplicitLayoutKHR = 4428,
-    WorkgroupMemoryExplicitLayout8BitAccessKHR = 4429,
-    WorkgroupMemoryExplicitLayout16BitAccessKHR = 4430,
-    SubgroupVoteKHR = 4431,
-    StorageBuffer16BitAccess = 4433,
-    StorageUniformBufferBlock16 = 4433,
-    StorageUniform16 = 4434,
-    UniformAndStorageBuffer16BitAccess = 4434,
-    StoragePushConstant16 = 4435,
-    StorageInputOutput16 = 4436,
-    DeviceGroup = 4437,
-    MultiView = 4439,
-    VariablePointersStorageBuffer = 4441,
-    VariablePointers = 4442,
-    AtomicStorageOps = 4445,
-    SampleMaskPostDepthCoverage = 4447,
-    StorageBuffer8BitAccess = 4448,
-    UniformAndStorageBuffer8BitAccess = 4449,
-    StoragePushConstant8 = 4450,
-    DenormPreserve = 4464,
-    DenormFlushToZero = 4465,
-    SignedZeroInfNanPreserve = 4466,
-    RoundingModeRTE = 4467,
-    RoundingModeRTZ = 4468,
-    RayQueryProvisionalKHR = 4471,
-    RayQueryKHR = 4472,
-    RayTraversalPrimitiveCullingKHR = 4478,
-    RayTracingKHR = 4479,
-    TextureSampleWeightedQCOM = 4484,
-    TextureBoxFilterQCOM = 4485,
-    TextureBlockMatchQCOM = 4486,
-    Float16ImageAMD = 5008,
-    ImageGatherBiasLodAMD = 5009,
-    FragmentMaskAMD = 5010,
-    StencilExportEXT = 5013,
-    ImageReadWriteLodAMD = 5015,
-    Int64ImageEXT = 5016,
-    ShaderClockKHR = 5055,
-    SampleMaskOverrideCoverageNV = 5249,
-    GeometryShaderPassthroughNV = 5251,
-    ShaderViewportIndexLayerEXT = 5254,
-    ShaderViewportIndexLayerNV = 5254,
-    ShaderViewportMaskNV = 5255,
-    ShaderStereoViewNV = 5259,
-    PerViewAttributesNV = 5260,
-    FragmentFullyCoveredEXT = 5265,
-    MeshShadingNV = 5266,
-    ImageFootprintNV = 5282,
-    MeshShadingEXT = 5283,
-    FragmentBarycentricKHR = 5284,
-    FragmentBarycentricNV = 5284,
-    ComputeDerivativeGroupQuadsNV = 5288,
-    FragmentDensityEXT = 5291,
-    ShadingRateNV = 5291,
-    GroupNonUniformPartitionedNV = 5297,
-    ShaderNonUniform = 5301,
-    ShaderNonUniformEXT = 5301,
-    RuntimeDescriptorArray = 5302,
-    RuntimeDescriptorArrayEXT = 5302,
-    InputAttachmentArrayDynamicIndexing = 5303,
-    InputAttachmentArrayDynamicIndexingEXT = 5303,
-    UniformTexelBufferArrayDynamicIndexing = 5304,
-    UniformTexelBufferArrayDynamicIndexingEXT = 5304,
-    StorageTexelBufferArrayDynamicIndexing = 5305,
-    StorageTexelBufferArrayDynamicIndexingEXT = 5305,
-    UniformBufferArrayNonUniformIndexing = 5306,
-    UniformBufferArrayNonUniformIndexingEXT = 5306,
-    SampledImageArrayNonUniformIndexing = 5307,
-    SampledImageArrayNonUniformIndexingEXT = 5307,
-    StorageBufferArrayNonUniformIndexing = 5308,
-    StorageBufferArrayNonUniformIndexingEXT = 5308,
-    StorageImageArrayNonUniformIndexing = 5309,
-    StorageImageArrayNonUniformIndexingEXT = 5309,
-    InputAttachmentArrayNonUniformIndexing = 5310,
-    InputAttachmentArrayNonUniformIndexingEXT = 5310,
-    UniformTexelBufferArrayNonUniformIndexing = 5311,
-    UniformTexelBufferArrayNonUniformIndexingEXT = 5311,
-    StorageTexelBufferArrayNonUniformIndexing = 5312,
-    StorageTexelBufferArrayNonUniformIndexingEXT = 5312,
-    RayTracingPositionFetchKHR = 5336,
-    RayTracingNV = 5340,
-    RayTracingMotionBlurNV = 5341,
-    VulkanMemoryModel = 5345,
-    VulkanMemoryModelKHR = 5345,
-    VulkanMemoryModelDeviceScope = 5346,
-    VulkanMemoryModelDeviceScopeKHR = 5346,
-    PhysicalStorageBufferAddresses = 5347,
-    PhysicalStorageBufferAddressesEXT = 5347,
-    ComputeDerivativeGroupLinearNV = 5350,
-    RayTracingProvisionalKHR = 5353,
-    CooperativeMatrixNV = 5357,
-    FragmentShaderSampleInterlockEXT = 5363,
-    FragmentShaderShadingRateInterlockEXT = 5372,
-    ShaderSMBuiltinsNV = 5373,
-    FragmentShaderPixelInterlockEXT = 5378,
-    DemoteToHelperInvocation = 5379,
-    DemoteToHelperInvocationEXT = 5379,
-    RayTracingOpacityMicromapEXT = 5381,
-    ShaderInvocationReorderNV = 5383,
-    BindlessTextureNV = 5390,
-    RayQueryPositionFetchKHR = 5391,
-    SubgroupShuffleINTEL = 5568,
-    SubgroupBufferBlockIOINTEL = 5569,
-    SubgroupImageBlockIOINTEL = 5570,
-    SubgroupImageMediaBlockIOINTEL = 5579,
-    RoundToInfinityINTEL = 5582,
-    FloatingPointModeINTEL = 5583,
-    IntegerFunctions2INTEL = 5584,
-    FunctionPointersINTEL = 5603,
-    IndirectReferencesINTEL = 5604,
-    AsmINTEL = 5606,
-    AtomicFloat32MinMaxEXT = 5612,
-    AtomicFloat64MinMaxEXT = 5613,
-    AtomicFloat16MinMaxEXT = 5616,
-    VectorComputeINTEL = 5617,
-    VectorAnyINTEL = 5619,
-    ExpectAssumeKHR = 5629,
-    SubgroupAvcMotionEstimationINTEL = 5696,
-    SubgroupAvcMotionEstimationIntraINTEL = 5697,
-    SubgroupAvcMotionEstimationChromaINTEL = 5698,
-    VariableLengthArrayINTEL = 5817,
-    FunctionFloatControlINTEL = 5821,
-    FPGAMemoryAttributesINTEL = 5824,
-    FPFastMathModeINTEL = 5837,
-    ArbitraryPrecisionIntegersINTEL = 5844,
-    ArbitraryPrecisionFloatingPointINTEL = 5845,
-    UnstructuredLoopControlsINTEL = 5886,
-    FPGALoopControlsINTEL = 5888,
-    KernelAttributesINTEL = 5892,
-    FPGAKernelAttributesINTEL = 5897,
-    FPGAMemoryAccessesINTEL = 5898,
-    FPGAClusterAttributesINTEL = 5904,
-    LoopFuseINTEL = 5906,
-    FPGADSPControlINTEL = 5908,
-    MemoryAccessAliasingINTEL = 5910,
-    FPGAInvocationPipeliningAttributesINTEL = 5916,
-    FPGABufferLocationINTEL = 5920,
-    ArbitraryPrecisionFixedPointINTEL = 5922,
-    USMStorageClassesINTEL = 5935,
-    RuntimeAlignedAttributeINTEL = 5939,
-    IOPipesINTEL = 5943,
-    BlockingPipesINTEL = 5945,
-    FPGARegINTEL = 5948,
-    DotProductInputAll = 6016,
-    DotProductInputAllKHR = 6016,
-    DotProductInput4x8Bit = 6017,
-    DotProductInput4x8BitKHR = 6017,
-    DotProductInput4x8BitPacked = 6018,
-    DotProductInput4x8BitPackedKHR = 6018,
-    DotProduct = 6019,
-    DotProductKHR = 6019,
-    RayCullMaskKHR = 6020,
-    BitInstructions = 6025,
-    GroupNonUniformRotateKHR = 6026,
-    AtomicFloat32AddEXT = 6033,
-    AtomicFloat64AddEXT = 6034,
-    LongConstantCompositeINTEL = 6089,
-    OptNoneINTEL = 6094,
-    AtomicFloat16AddEXT = 6095,
-    DebugInfoModuleINTEL = 6114,
-    BFloat16ConversionINTEL = 6115,
-    SplitBarrierINTEL = 6141,
-    FPGAKernelAttributesv2INTEL = 6161,
-    FPGALatencyControlINTEL = 6171,
-    FPGAArgumentInterfacesINTEL = 6174,
-    GroupUniformArithmeticKHR = 6400,
-    Max = 0x7fffffff,
+  Matrix = 0,
+  Shader = 1,
+  Geometry = 2,
+  Tessellation = 3,
+  Addresses = 4,
+  Linkage = 5,
+  Kernel = 6,
+  Vector16 = 7,
+  Float16Buffer = 8,
+  Float16 = 9,
+  Float64 = 10,
+  Int64 = 11,
+  Int64Atomics = 12,
+  ImageBasic = 13,
+  ImageReadWrite = 14,
+  ImageMipmap = 15,
+  Pipes = 17,
+  Groups = 18,
+  DeviceEnqueue = 19,
+  LiteralSampler = 20,
+  AtomicStorage = 21,
+  Int16 = 22,
+  TessellationPointSize = 23,
+  GeometryPointSize = 24,
+  ImageGatherExtended = 25,
+  StorageImageMultisample = 27,
+  UniformBufferArrayDynamicIndexing = 28,
+  SampledImageArrayDynamicIndexing = 29,
+  StorageBufferArrayDynamicIndexing = 30,
+  StorageImageArrayDynamicIndexing = 31,
+  ClipDistance = 32,
+  CullDistance = 33,
+  ImageCubeArray = 34,
+  SampleRateShading = 35,
+  ImageRect = 36,
+  SampledRect = 37,
+  GenericPointer = 38,
+  Int8 = 39,
+  InputAttachment = 40,
+  SparseResidency = 41,
+  MinLod = 42,
+  Sampled1D = 43,
+  Image1D = 44,
+  SampledCubeArray = 45,
+  SampledBuffer = 46,
+  ImageBuffer = 47,
+  ImageMSArray = 48,
+  StorageImageExtendedFormats = 49,
+  ImageQuery = 50,
+  DerivativeControl = 51,
+  InterpolationFunction = 52,
+  TransformFeedback = 53,
+  GeometryStreams = 54,
+  StorageImageReadWithoutFormat = 55,
+  StorageImageWriteWithoutFormat = 56,
+  MultiViewport = 57,
+  SubgroupDispatch = 58,
+  NamedBarrier = 59,
+  PipeStorage = 60,
+  GroupNonUniform = 61,
+  GroupNonUniformVote = 62,
+  GroupNonUniformArithmetic = 63,
+  GroupNonUniformBallot = 64,
+  GroupNonUniformShuffle = 65,
+  GroupNonUniformShuffleRelative = 66,
+  GroupNonUniformClustered = 67,
+  GroupNonUniformQuad = 68,
+  ShaderLayer = 69,
+  ShaderViewportIndex = 70,
+  UniformDecoration = 71,
+  CoreBuiltinsARM = 4165,
+  TileImageColorReadAccessEXT = 4166,
+  TileImageDepthReadAccessEXT = 4167,
+  TileImageStencilReadAccessEXT = 4168,
+  FragmentShadingRateKHR = 4422,
+  SubgroupBallotKHR = 4423,
+  DrawParameters = 4427,
+  WorkgroupMemoryExplicitLayoutKHR = 4428,
+  WorkgroupMemoryExplicitLayout8BitAccessKHR = 4429,
+  WorkgroupMemoryExplicitLayout16BitAccessKHR = 4430,
+  SubgroupVoteKHR = 4431,
+  StorageBuffer16BitAccess = 4433,
+  StorageUniformBufferBlock16 = 4433,
+  StorageUniform16 = 4434,
+  UniformAndStorageBuffer16BitAccess = 4434,
+  StoragePushConstant16 = 4435,
+  StorageInputOutput16 = 4436,
+  DeviceGroup = 4437,
+  MultiView = 4439,
+  VariablePointersStorageBuffer = 4441,
+  VariablePointers = 4442,
+  AtomicStorageOps = 4445,
+  SampleMaskPostDepthCoverage = 4447,
+  StorageBuffer8BitAccess = 4448,
+  UniformAndStorageBuffer8BitAccess = 4449,
+  StoragePushConstant8 = 4450,
+  DenormPreserve = 4464,
+  DenormFlushToZero = 4465,
+  SignedZeroInfNanPreserve = 4466,
+  RoundingModeRTE = 4467,
+  RoundingModeRTZ = 4468,
+  RayQueryProvisionalKHR = 4471,
+  RayQueryKHR = 4472,
+  RayTraversalPrimitiveCullingKHR = 4478,
+  RayTracingKHR = 4479,
+  TextureSampleWeightedQCOM = 4484,
+  TextureBoxFilterQCOM = 4485,
+  TextureBlockMatchQCOM = 4486,
+  Float16ImageAMD = 5008,
+  ImageGatherBiasLodAMD = 5009,
+  FragmentMaskAMD = 5010,
+  StencilExportEXT = 5013,
+  ImageReadWriteLodAMD = 5015,
+  Int64ImageEXT = 5016,
+  ShaderClockKHR = 5055,
+  SampleMaskOverrideCoverageNV = 5249,
+  GeometryShaderPassthroughNV = 5251,
+  ShaderViewportIndexLayerEXT = 5254,
+  ShaderViewportIndexLayerNV = 5254,
+  ShaderViewportMaskNV = 5255,
+  ShaderStereoViewNV = 5259,
+  PerViewAttributesNV = 5260,
+  FragmentFullyCoveredEXT = 5265,
+  MeshShadingNV = 5266,
+  ImageFootprintNV = 5282,
+  MeshShadingEXT = 5283,
+  FragmentBarycentricKHR = 5284,
+  FragmentBarycentricNV = 5284,
+  ComputeDerivativeGroupQuadsNV = 5288,
+  FragmentDensityEXT = 5291,
+  ShadingRateNV = 5291,
+  GroupNonUniformPartitionedNV = 5297,
+  ShaderNonUniform = 5301,
+  ShaderNonUniformEXT = 5301,
+  RuntimeDescriptorArray = 5302,
+  RuntimeDescriptorArrayEXT = 5302,
+  InputAttachmentArrayDynamicIndexing = 5303,
+  InputAttachmentArrayDynamicIndexingEXT = 5303,
+  UniformTexelBufferArrayDynamicIndexing = 5304,
+  UniformTexelBufferArrayDynamicIndexingEXT = 5304,
+  StorageTexelBufferArrayDynamicIndexing = 5305,
+  StorageTexelBufferArrayDynamicIndexingEXT = 5305,
+  UniformBufferArrayNonUniformIndexing = 5306,
+  UniformBufferArrayNonUniformIndexingEXT = 5306,
+  SampledImageArrayNonUniformIndexing = 5307,
+  SampledImageArrayNonUniformIndexingEXT = 5307,
+  StorageBufferArrayNonUniformIndexing = 5308,
+  StorageBufferArrayNonUniformIndexingEXT = 5308,
+  StorageImageArrayNonUniformIndexing = 5309,
+  StorageImageArrayNonUniformIndexingEXT = 5309,
+  InputAttachmentArrayNonUniformIndexing = 5310,
+  InputAttachmentArrayNonUniformIndexingEXT = 5310,
+  UniformTexelBufferArrayNonUniformIndexing = 5311,
+  UniformTexelBufferArrayNonUniformIndexingEXT = 5311,
+  StorageTexelBufferArrayNonUniformIndexing = 5312,
+  StorageTexelBufferArrayNonUniformIndexingEXT = 5312,
+  RayTracingPositionFetchKHR = 5336,
+  RayTracingNV = 5340,
+  RayTracingMotionBlurNV = 5341,
+  VulkanMemoryModel = 5345,
+  VulkanMemoryModelKHR = 5345,
+  VulkanMemoryModelDeviceScope = 5346,
+  VulkanMemoryModelDeviceScopeKHR = 5346,
+  PhysicalStorageBufferAddresses = 5347,
+  PhysicalStorageBufferAddressesEXT = 5347,
+  ComputeDerivativeGroupLinearNV = 5350,
+  RayTracingProvisionalKHR = 5353,
+  CooperativeMatrixNV = 5357,
+  FragmentShaderSampleInterlockEXT = 5363,
+  FragmentShaderShadingRateInterlockEXT = 5372,
+  ShaderSMBuiltinsNV = 5373,
+  FragmentShaderPixelInterlockEXT = 5378,
+  DemoteToHelperInvocation = 5379,
+  DemoteToHelperInvocationEXT = 5379,
+  RayTracingOpacityMicromapEXT = 5381,
+  ShaderInvocationReorderNV = 5383,
+  BindlessTextureNV = 5390,
+  RayQueryPositionFetchKHR = 5391,
+  SubgroupShuffleINTEL = 5568,
+  SubgroupBufferBlockIOINTEL = 5569,
+  SubgroupImageBlockIOINTEL = 5570,
+  SubgroupImageMediaBlockIOINTEL = 5579,
+  RoundToInfinityINTEL = 5582,
+  FloatingPointModeINTEL = 5583,
+  IntegerFunctions2INTEL = 5584,
+  FunctionPointersINTEL = 5603,
+  IndirectReferencesINTEL = 5604,
+  AsmINTEL = 5606,
+  AtomicFloat32MinMaxEXT = 5612,
+  AtomicFloat64MinMaxEXT = 5613,
+  AtomicFloat16MinMaxEXT = 5616,
+  VectorComputeINTEL = 5617,
+  VectorAnyINTEL = 5619,
+  ExpectAssumeKHR = 5629,
+  SubgroupAvcMotionEstimationINTEL = 5696,
+  SubgroupAvcMotionEstimationIntraINTEL = 5697,
+  SubgroupAvcMotionEstimationChromaINTEL = 5698,
+  VariableLengthArrayINTEL = 5817,
+  FunctionFloatControlINTEL = 5821,
+  FPGAMemoryAttributesINTEL = 5824,
+  FPFastMathModeINTEL = 5837,
+  ArbitraryPrecisionIntegersINTEL = 5844,
+  ArbitraryPrecisionFloatingPointINTEL = 5845,
+  UnstructuredLoopControlsINTEL = 5886,
+  FPGALoopControlsINTEL = 5888,
+  KernelAttributesINTEL = 5892,
+  FPGAKernelAttributesINTEL = 5897,
+  FPGAMemoryAccessesINTEL = 5898,
+  FPGAClusterAttributesINTEL = 5904,
+  LoopFuseINTEL = 5906,
+  FPGADSPControlINTEL = 5908,
+  MemoryAccessAliasingINTEL = 5910,
+  FPGAInvocationPipeliningAttributesINTEL = 5916,
+  FPGABufferLocationINTEL = 5920,
+  ArbitraryPrecisionFixedPointINTEL = 5922,
+  USMStorageClassesINTEL = 5935,
+  RuntimeAlignedAttributeINTEL = 5939,
+  IOPipesINTEL = 5943,
+  BlockingPipesINTEL = 5945,
+  FPGARegINTEL = 5948,
+  DotProductInputAll = 6016,
+  DotProductInputAllKHR = 6016,
+  DotProductInput4x8Bit = 6017,
+  DotProductInput4x8BitKHR = 6017,
+  DotProductInput4x8BitPacked = 6018,
+  DotProductInput4x8BitPackedKHR = 6018,
+  DotProduct = 6019,
+  DotProductKHR = 6019,
+  RayCullMaskKHR = 6020,
+  BitInstructions = 6025,
+  GroupNonUniformRotateKHR = 6026,
+  AtomicFloat32AddEXT = 6033,
+  AtomicFloat64AddEXT = 6034,
+  LongConstantCompositeINTEL = 6089,
+  OptNoneINTEL = 6094,
+  AtomicFloat16AddEXT = 6095,
+  DebugInfoModuleINTEL = 6114,
+  BFloat16ConversionINTEL = 6115,
+  SplitBarrierINTEL = 6141,
+  FPGAKernelAttributesv2INTEL = 6161,
+  FPGALatencyControlINTEL = 6171,
+  FPGAArgumentInterfacesINTEL = 6174,
+  GroupUniformArithmeticKHR = 6400,
+  Max = 0x7fffffff,
 };
 
 enum class RayFlagsShift : unsigned {
-    OpaqueKHR = 0,
-    NoOpaqueKHR = 1,
-    TerminateOnFirstHitKHR = 2,
-    SkipClosestHitShaderKHR = 3,
-    CullBackFacingTrianglesKHR = 4,
-    CullFrontFacingTrianglesKHR = 5,
-    CullOpaqueKHR = 6,
-    CullNoOpaqueKHR = 7,
-    SkipTrianglesKHR = 8,
-    SkipAABBsKHR = 9,
-    ForceOpacityMicromap2StateEXT = 10,
-    Max = 0x7fffffff,
+  OpaqueKHR = 0,
+  NoOpaqueKHR = 1,
+  TerminateOnFirstHitKHR = 2,
+  SkipClosestHitShaderKHR = 3,
+  CullBackFacingTrianglesKHR = 4,
+  CullFrontFacingTrianglesKHR = 5,
+  CullOpaqueKHR = 6,
+  CullNoOpaqueKHR = 7,
+  SkipTrianglesKHR = 8,
+  SkipAABBsKHR = 9,
+  ForceOpacityMicromap2StateEXT = 10,
+  Max = 0x7fffffff,
 };
 
 enum class RayFlagsMask : unsigned {
-    MaskNone = 0,
-    OpaqueKHR = 0x00000001,
-    NoOpaqueKHR = 0x00000002,
-    TerminateOnFirstHitKHR = 0x00000004,
-    SkipClosestHitShaderKHR = 0x00000008,
-    CullBackFacingTrianglesKHR = 0x00000010,
-    CullFrontFacingTrianglesKHR = 0x00000020,
-    CullOpaqueKHR = 0x00000040,
-    CullNoOpaqueKHR = 0x00000080,
-    SkipTrianglesKHR = 0x00000100,
-    SkipAABBsKHR = 0x00000200,
-    ForceOpacityMicromap2StateEXT = 0x00000400,
+  MaskNone = 0,
+  OpaqueKHR = 0x00000001,
+  NoOpaqueKHR = 0x00000002,
+  TerminateOnFirstHitKHR = 0x00000004,
+  SkipClosestHitShaderKHR = 0x00000008,
+  CullBackFacingTrianglesKHR = 0x00000010,
+  CullFrontFacingTrianglesKHR = 0x00000020,
+  CullOpaqueKHR = 0x00000040,
+  CullNoOpaqueKHR = 0x00000080,
+  SkipTrianglesKHR = 0x00000100,
+  SkipAABBsKHR = 0x00000200,
+  ForceOpacityMicromap2StateEXT = 0x00000400,
 };
 
 enum class RayQueryIntersection : unsigned {
-    RayQueryCandidateIntersectionKHR = 0,
-    RayQueryCommittedIntersectionKHR = 1,
-    Max = 0x7fffffff,
+  RayQueryCandidateIntersectionKHR = 0,
+  RayQueryCommittedIntersectionKHR = 1,
+  Max = 0x7fffffff,
 };
 
 enum class RayQueryCommittedIntersectionType : unsigned {
-    RayQueryCommittedIntersectionNoneKHR = 0,
-    RayQueryCommittedIntersectionTriangleKHR = 1,
-    RayQueryCommittedIntersectionGeneratedKHR = 2,
-    Max = 0x7fffffff,
+  RayQueryCommittedIntersectionNoneKHR = 0,
+  RayQueryCommittedIntersectionTriangleKHR = 1,
+  RayQueryCommittedIntersectionGeneratedKHR = 2,
+  Max = 0x7fffffff,
 };
 
 enum class RayQueryCandidateIntersectionType : unsigned {
-    RayQueryCandidateIntersectionTriangleKHR = 0,
-    RayQueryCandidateIntersectionAABBKHR = 1,
-    Max = 0x7fffffff,
+  RayQueryCandidateIntersectionTriangleKHR = 0,
+  RayQueryCandidateIntersectionAABBKHR = 1,
+  Max = 0x7fffffff,
 };
 
 enum class FragmentShadingRateShift : unsigned {
-    Vertical2Pixels = 0,
-    Vertical4Pixels = 1,
-    Horizontal2Pixels = 2,
-    Horizontal4Pixels = 3,
-    Max = 0x7fffffff,
+  Vertical2Pixels = 0,
+  Vertical4Pixels = 1,
+  Horizontal2Pixels = 2,
+  Horizontal4Pixels = 3,
+  Max = 0x7fffffff,
 };
 
 enum class FragmentShadingRateMask : unsigned {
-    MaskNone = 0,
-    Vertical2Pixels = 0x00000001,
-    Vertical4Pixels = 0x00000002,
-    Horizontal2Pixels = 0x00000004,
-    Horizontal4Pixels = 0x00000008,
+  MaskNone = 0,
+  Vertical2Pixels = 0x00000001,
+  Vertical4Pixels = 0x00000002,
+  Horizontal2Pixels = 0x00000004,
+  Horizontal4Pixels = 0x00000008,
 };
 
 enum class FPDenormMode : unsigned {
-    Preserve = 0,
-    FlushToZero = 1,
-    Max = 0x7fffffff,
+  Preserve = 0,
+  FlushToZero = 1,
+  Max = 0x7fffffff,
 };
 
 enum class FPOperationMode : unsigned {
-    IEEE = 0,
-    ALT = 1,
-    Max = 0x7fffffff,
+  IEEE = 0,
+  ALT = 1,
+  Max = 0x7fffffff,
 };
 
 enum class QuantizationModes : unsigned {
-    TRN = 0,
-    TRN_ZERO = 1,
-    RND = 2,
-    RND_ZERO = 3,
-    RND_INF = 4,
-    RND_MIN_INF = 5,
-    RND_CONV = 6,
-    RND_CONV_ODD = 7,
-    Max = 0x7fffffff,
+  TRN = 0,
+  TRN_ZERO = 1,
+  RND = 2,
+  RND_ZERO = 3,
+  RND_INF = 4,
+  RND_MIN_INF = 5,
+  RND_CONV = 6,
+  RND_CONV_ODD = 7,
+  Max = 0x7fffffff,
 };
 
 enum class OverflowModes : unsigned {
-    WRAP = 0,
-    SAT = 1,
-    SAT_ZERO = 2,
-    SAT_SYM = 3,
-    Max = 0x7fffffff,
+  WRAP = 0,
+  SAT = 1,
+  SAT_ZERO = 2,
+  SAT_SYM = 3,
+  Max = 0x7fffffff,
 };
 
 enum class PackedVectorFormat : unsigned {
-    PackedVectorFormat4x8Bit = 0,
-    PackedVectorFormat4x8BitKHR = 0,
-    Max = 0x7fffffff,
+  PackedVectorFormat4x8Bit = 0,
+  PackedVectorFormat4x8BitKHR = 0,
+  Max = 0x7fffffff,
 };
 
 enum class Op : unsigned {
-    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,
-    OpColorAttachmentReadEXT = 4160,
-    OpDepthAttachmentReadEXT = 4161,
-    OpStencilAttachmentReadEXT = 4162,
-    OpTerminateInvocation = 4416,
-    OpSubgroupBallotKHR = 4421,
-    OpSubgroupFirstInvocationKHR = 4422,
-    OpSubgroupAllKHR = 4428,
-    OpSubgroupAnyKHR = 4429,
-    OpSubgroupAllEqualKHR = 4430,
-    OpGroupNonUniformRotateKHR = 4431,
-    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,
-    OpImageSampleWeightedQCOM = 4480,
-    OpImageBoxFilterQCOM = 4481,
-    OpImageBlockMatchSSDQCOM = 4482,
-    OpImageBlockMatchSADQCOM = 4483,
-    OpGroupIAddNonUniformAMD = 5000,
-    OpGroupFAddNonUniformAMD = 5001,
-    OpGroupFMinNonUniformAMD = 5002,
-    OpGroupUMinNonUniformAMD = 5003,
-    OpGroupSMinNonUniformAMD = 5004,
-    OpGroupFMaxNonUniformAMD = 5005,
-    OpGroupUMaxNonUniformAMD = 5006,
-    OpGroupSMaxNonUniformAMD = 5007,
-    OpFragmentMaskFetchAMD = 5011,
-    OpFragmentFetchAMD = 5012,
-    OpReadClockKHR = 5056,
-    OpHitObjectRecordHitMotionNV = 5249,
-    OpHitObjectRecordHitWithIndexMotionNV = 5250,
-    OpHitObjectRecordMissMotionNV = 5251,
-    OpHitObjectGetWorldToObjectNV = 5252,
-    OpHitObjectGetObjectToWorldNV = 5253,
-    OpHitObjectGetObjectRayDirectionNV = 5254,
-    OpHitObjectGetObjectRayOriginNV = 5255,
-    OpHitObjectTraceRayMotionNV = 5256,
-    OpHitObjectGetShaderRecordBufferHandleNV = 5257,
-    OpHitObjectGetShaderBindingTableRecordIndexNV = 5258,
-    OpHitObjectRecordEmptyNV = 5259,
-    OpHitObjectTraceRayNV = 5260,
-    OpHitObjectRecordHitNV = 5261,
-    OpHitObjectRecordHitWithIndexNV = 5262,
-    OpHitObjectRecordMissNV = 5263,
-    OpHitObjectExecuteShaderNV = 5264,
-    OpHitObjectGetCurrentTimeNV = 5265,
-    OpHitObjectGetAttributesNV = 5266,
-    OpHitObjectGetHitKindNV = 5267,
-    OpHitObjectGetPrimitiveIndexNV = 5268,
-    OpHitObjectGetGeometryIndexNV = 5269,
-    OpHitObjectGetInstanceIdNV = 5270,
-    OpHitObjectGetInstanceCustomIndexNV = 5271,
-    OpHitObjectGetWorldRayDirectionNV = 5272,
-    OpHitObjectGetWorldRayOriginNV = 5273,
-    OpHitObjectGetRayTMaxNV = 5274,
-    OpHitObjectGetRayTMinNV = 5275,
-    OpHitObjectIsEmptyNV = 5276,
-    OpHitObjectIsHitNV = 5277,
-    OpHitObjectIsMissNV = 5278,
-    OpReorderThreadWithHitObjectNV = 5279,
-    OpReorderThreadWithHintNV = 5280,
-    OpTypeHitObjectNV = 5281,
-    OpImageSampleFootprintNV = 5283,
-    OpEmitMeshTasksEXT = 5294,
-    OpSetMeshOutputsEXT = 5295,
-    OpGroupNonUniformPartitionNV = 5296,
-    OpWritePackedPrimitiveIndices4x8NV = 5299,
-    OpReportIntersectionKHR = 5334,
-    OpReportIntersectionNV = 5334,
-    OpIgnoreIntersectionNV = 5335,
-    OpTerminateRayNV = 5336,
-    OpTraceNV = 5337,
-    OpTraceMotionNV = 5338,
-    OpTraceRayMotionNV = 5339,
-    OpRayQueryGetIntersectionTriangleVertexPositionsKHR = 5340,
-    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,
-    OpAliasDomainDeclINTEL = 5911,
-    OpAliasScopeDeclINTEL = 5912,
-    OpAliasScopeListDeclINTEL = 5913,
-    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,
-    OpConvertFToBF16INTEL = 6116,
-    OpConvertBF16ToFINTEL = 6117,
-    OpControlBarrierArriveINTEL = 6142,
-    OpControlBarrierWaitINTEL = 6143,
-    OpGroupIMulKHR = 6401,
-    OpGroupFMulKHR = 6402,
-    OpGroupBitwiseAndKHR = 6403,
-    OpGroupBitwiseOrKHR = 6404,
-    OpGroupBitwiseXorKHR = 6405,
-    OpGroupLogicalAndKHR = 6406,
-    OpGroupLogicalOrKHR = 6407,
-    OpGroupLogicalXorKHR = 6408,
-    Max = 0x7fffffff,
+  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,
+  OpColorAttachmentReadEXT = 4160,
+  OpDepthAttachmentReadEXT = 4161,
+  OpStencilAttachmentReadEXT = 4162,
+  OpTerminateInvocation = 4416,
+  OpSubgroupBallotKHR = 4421,
+  OpSubgroupFirstInvocationKHR = 4422,
+  OpSubgroupAllKHR = 4428,
+  OpSubgroupAnyKHR = 4429,
+  OpSubgroupAllEqualKHR = 4430,
+  OpGroupNonUniformRotateKHR = 4431,
+  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,
+  OpImageSampleWeightedQCOM = 4480,
+  OpImageBoxFilterQCOM = 4481,
+  OpImageBlockMatchSSDQCOM = 4482,
+  OpImageBlockMatchSADQCOM = 4483,
+  OpGroupIAddNonUniformAMD = 5000,
+  OpGroupFAddNonUniformAMD = 5001,
+  OpGroupFMinNonUniformAMD = 5002,
+  OpGroupUMinNonUniformAMD = 5003,
+  OpGroupSMinNonUniformAMD = 5004,
+  OpGroupFMaxNonUniformAMD = 5005,
+  OpGroupUMaxNonUniformAMD = 5006,
+  OpGroupSMaxNonUniformAMD = 5007,
+  OpFragmentMaskFetchAMD = 5011,
+  OpFragmentFetchAMD = 5012,
+  OpReadClockKHR = 5056,
+  OpHitObjectRecordHitMotionNV = 5249,
+  OpHitObjectRecordHitWithIndexMotionNV = 5250,
+  OpHitObjectRecordMissMotionNV = 5251,
+  OpHitObjectGetWorldToObjectNV = 5252,
+  OpHitObjectGetObjectToWorldNV = 5253,
+  OpHitObjectGetObjectRayDirectionNV = 5254,
+  OpHitObjectGetObjectRayOriginNV = 5255,
+  OpHitObjectTraceRayMotionNV = 5256,
+  OpHitObjectGetShaderRecordBufferHandleNV = 5257,
+  OpHitObjectGetShaderBindingTableRecordIndexNV = 5258,
+  OpHitObjectRecordEmptyNV = 5259,
+  OpHitObjectTraceRayNV = 5260,
+  OpHitObjectRecordHitNV = 5261,
+  OpHitObjectRecordHitWithIndexNV = 5262,
+  OpHitObjectRecordMissNV = 5263,
+  OpHitObjectExecuteShaderNV = 5264,
+  OpHitObjectGetCurrentTimeNV = 5265,
+  OpHitObjectGetAttributesNV = 5266,
+  OpHitObjectGetHitKindNV = 5267,
+  OpHitObjectGetPrimitiveIndexNV = 5268,
+  OpHitObjectGetGeometryIndexNV = 5269,
+  OpHitObjectGetInstanceIdNV = 5270,
+  OpHitObjectGetInstanceCustomIndexNV = 5271,
+  OpHitObjectGetWorldRayDirectionNV = 5272,
+  OpHitObjectGetWorldRayOriginNV = 5273,
+  OpHitObjectGetRayTMaxNV = 5274,
+  OpHitObjectGetRayTMinNV = 5275,
+  OpHitObjectIsEmptyNV = 5276,
+  OpHitObjectIsHitNV = 5277,
+  OpHitObjectIsMissNV = 5278,
+  OpReorderThreadWithHitObjectNV = 5279,
+  OpReorderThreadWithHintNV = 5280,
+  OpTypeHitObjectNV = 5281,
+  OpImageSampleFootprintNV = 5283,
+  OpEmitMeshTasksEXT = 5294,
+  OpSetMeshOutputsEXT = 5295,
+  OpGroupNonUniformPartitionNV = 5296,
+  OpWritePackedPrimitiveIndices4x8NV = 5299,
+  OpReportIntersectionKHR = 5334,
+  OpReportIntersectionNV = 5334,
+  OpIgnoreIntersectionNV = 5335,
+  OpTerminateRayNV = 5336,
+  OpTraceNV = 5337,
+  OpTraceMotionNV = 5338,
+  OpTraceRayMotionNV = 5339,
+  OpRayQueryGetIntersectionTriangleVertexPositionsKHR = 5340,
+  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,
+  OpAliasDomainDeclINTEL = 5911,
+  OpAliasScopeDeclINTEL = 5912,
+  OpAliasScopeListDeclINTEL = 5913,
+  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,
+  OpConvertFToBF16INTEL = 6116,
+  OpConvertBF16ToFINTEL = 6117,
+  OpControlBarrierArriveINTEL = 6142,
+  OpControlBarrierWaitINTEL = 6143,
+  OpGroupIMulKHR = 6401,
+  OpGroupFMulKHR = 6402,
+  OpGroupBitwiseAndKHR = 6403,
+  OpGroupBitwiseOrKHR = 6404,
+  OpGroupBitwiseXorKHR = 6405,
+  OpGroupLogicalAndKHR = 6406,
+  OpGroupLogicalOrKHR = 6407,
+  OpGroupLogicalXorKHR = 6408,
+  Max = 0x7fffffff,
 };
 
 #ifdef SPV_ENABLE_UTILITY_CODE
@@ -1995,759 +1999,2970 @@ enum class Op : unsigned {
 #include <stdbool.h>
 #endif
 inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
-    *hasResult = *hasResultType = false;
-    switch (opcode) {
-    default: /* unknown opcode */ break;
-    case Op::OpNop: *hasResult = false; *hasResultType = false; break;
-    case Op::OpUndef: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSourceContinued: *hasResult = false; *hasResultType = false; break;
-    case Op::OpSource: *hasResult = false; *hasResultType = false; break;
-    case Op::OpSourceExtension: *hasResult = false; *hasResultType = false; break;
-    case Op::OpName: *hasResult = false; *hasResultType = false; break;
-    case Op::OpMemberName: *hasResult = false; *hasResultType = false; break;
-    case Op::OpString: *hasResult = true; *hasResultType = false; break;
-    case Op::OpLine: *hasResult = false; *hasResultType = false; break;
-    case Op::OpExtension: *hasResult = false; *hasResultType = false; break;
-    case Op::OpExtInstImport: *hasResult = true; *hasResultType = false; break;
-    case Op::OpExtInst: *hasResult = true; *hasResultType = true; break;
-    case Op::OpMemoryModel: *hasResult = false; *hasResultType = false; break;
-    case Op::OpEntryPoint: *hasResult = false; *hasResultType = false; break;
-    case Op::OpExecutionMode: *hasResult = false; *hasResultType = false; break;
-    case Op::OpCapability: *hasResult = false; *hasResultType = false; break;
-    case Op::OpTypeVoid: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeBool: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeInt: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeFloat: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeVector: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeMatrix: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeImage: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeSampler: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeSampledImage: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeArray: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeRuntimeArray: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeStruct: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeOpaque: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypePointer: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeFunction: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeEvent: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeDeviceEvent: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeReserveId: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeQueue: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypePipe: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeForwardPointer: *hasResult = false; *hasResultType = false; break;
-    case Op::OpConstantTrue: *hasResult = true; *hasResultType = true; break;
-    case Op::OpConstantFalse: *hasResult = true; *hasResultType = true; break;
-    case Op::OpConstant: *hasResult = true; *hasResultType = true; break;
-    case Op::OpConstantComposite: *hasResult = true; *hasResultType = true; break;
-    case Op::OpConstantSampler: *hasResult = true; *hasResultType = true; break;
-    case Op::OpConstantNull: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSpecConstantTrue: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSpecConstantFalse: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSpecConstant: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSpecConstantComposite: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSpecConstantOp: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFunction: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFunctionParameter: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFunctionEnd: *hasResult = false; *hasResultType = false; break;
-    case Op::OpFunctionCall: *hasResult = true; *hasResultType = true; break;
-    case Op::OpVariable: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageTexelPointer: *hasResult = true; *hasResultType = true; break;
-    case Op::OpLoad: *hasResult = true; *hasResultType = true; break;
-    case Op::OpStore: *hasResult = false; *hasResultType = false; break;
-    case Op::OpCopyMemory: *hasResult = false; *hasResultType = false; break;
-    case Op::OpCopyMemorySized: *hasResult = false; *hasResultType = false; break;
-    case Op::OpAccessChain: *hasResult = true; *hasResultType = true; break;
-    case Op::OpInBoundsAccessChain: *hasResult = true; *hasResultType = true; break;
-    case Op::OpPtrAccessChain: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArrayLength: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGenericPtrMemSemantics: *hasResult = true; *hasResultType = true; break;
-    case Op::OpInBoundsPtrAccessChain: *hasResult = true; *hasResultType = true; break;
-    case Op::OpDecorate: *hasResult = false; *hasResultType = false; break;
-    case Op::OpMemberDecorate: *hasResult = false; *hasResultType = false; break;
-    case Op::OpDecorationGroup: *hasResult = true; *hasResultType = false; break;
-    case Op::OpGroupDecorate: *hasResult = false; *hasResultType = false; break;
-    case Op::OpGroupMemberDecorate: *hasResult = false; *hasResultType = false; break;
-    case Op::OpVectorExtractDynamic: *hasResult = true; *hasResultType = true; break;
-    case Op::OpVectorInsertDynamic: *hasResult = true; *hasResultType = true; break;
-    case Op::OpVectorShuffle: *hasResult = true; *hasResultType = true; break;
-    case Op::OpCompositeConstruct: *hasResult = true; *hasResultType = true; break;
-    case Op::OpCompositeExtract: *hasResult = true; *hasResultType = true; break;
-    case Op::OpCompositeInsert: *hasResult = true; *hasResultType = true; break;
-    case Op::OpCopyObject: *hasResult = true; *hasResultType = true; break;
-    case Op::OpTranspose: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSampledImage: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageSampleImplicitLod: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageSampleExplicitLod: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageFetch: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageGather: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageDrefGather: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageRead: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageWrite: *hasResult = false; *hasResultType = false; break;
-    case Op::OpImage: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageQueryFormat: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageQueryOrder: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageQuerySizeLod: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageQuerySize: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageQueryLod: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageQueryLevels: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageQuerySamples: *hasResult = true; *hasResultType = true; break;
-    case Op::OpConvertFToU: *hasResult = true; *hasResultType = true; break;
-    case Op::OpConvertFToS: *hasResult = true; *hasResultType = true; break;
-    case Op::OpConvertSToF: *hasResult = true; *hasResultType = true; break;
-    case Op::OpConvertUToF: *hasResult = true; *hasResultType = true; break;
-    case Op::OpUConvert: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSConvert: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFConvert: *hasResult = true; *hasResultType = true; break;
-    case Op::OpQuantizeToF16: *hasResult = true; *hasResultType = true; break;
-    case Op::OpConvertPtrToU: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSatConvertSToU: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSatConvertUToS: *hasResult = true; *hasResultType = true; break;
-    case Op::OpConvertUToPtr: *hasResult = true; *hasResultType = true; break;
-    case Op::OpPtrCastToGeneric: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGenericCastToPtr: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGenericCastToPtrExplicit: *hasResult = true; *hasResultType = true; break;
-    case Op::OpBitcast: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSNegate: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFNegate: *hasResult = true; *hasResultType = true; break;
-    case Op::OpIAdd: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFAdd: *hasResult = true; *hasResultType = true; break;
-    case Op::OpISub: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFSub: *hasResult = true; *hasResultType = true; break;
-    case Op::OpIMul: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFMul: *hasResult = true; *hasResultType = true; break;
-    case Op::OpUDiv: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSDiv: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFDiv: *hasResult = true; *hasResultType = true; break;
-    case Op::OpUMod: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSRem: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSMod: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFRem: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFMod: *hasResult = true; *hasResultType = true; break;
-    case Op::OpVectorTimesScalar: *hasResult = true; *hasResultType = true; break;
-    case Op::OpMatrixTimesScalar: *hasResult = true; *hasResultType = true; break;
-    case Op::OpVectorTimesMatrix: *hasResult = true; *hasResultType = true; break;
-    case Op::OpMatrixTimesVector: *hasResult = true; *hasResultType = true; break;
-    case Op::OpMatrixTimesMatrix: *hasResult = true; *hasResultType = true; break;
-    case Op::OpOuterProduct: *hasResult = true; *hasResultType = true; break;
-    case Op::OpDot: *hasResult = true; *hasResultType = true; break;
-    case Op::OpIAddCarry: *hasResult = true; *hasResultType = true; break;
-    case Op::OpISubBorrow: *hasResult = true; *hasResultType = true; break;
-    case Op::OpUMulExtended: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSMulExtended: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAny: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAll: *hasResult = true; *hasResultType = true; break;
-    case Op::OpIsNan: *hasResult = true; *hasResultType = true; break;
-    case Op::OpIsInf: *hasResult = true; *hasResultType = true; break;
-    case Op::OpIsFinite: *hasResult = true; *hasResultType = true; break;
-    case Op::OpIsNormal: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSignBitSet: *hasResult = true; *hasResultType = true; break;
-    case Op::OpLessOrGreater: *hasResult = true; *hasResultType = true; break;
-    case Op::OpOrdered: *hasResult = true; *hasResultType = true; break;
-    case Op::OpUnordered: *hasResult = true; *hasResultType = true; break;
-    case Op::OpLogicalEqual: *hasResult = true; *hasResultType = true; break;
-    case Op::OpLogicalNotEqual: *hasResult = true; *hasResultType = true; break;
-    case Op::OpLogicalOr: *hasResult = true; *hasResultType = true; break;
-    case Op::OpLogicalAnd: *hasResult = true; *hasResultType = true; break;
-    case Op::OpLogicalNot: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSelect: *hasResult = true; *hasResultType = true; break;
-    case Op::OpIEqual: *hasResult = true; *hasResultType = true; break;
-    case Op::OpINotEqual: *hasResult = true; *hasResultType = true; break;
-    case Op::OpUGreaterThan: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSGreaterThan: *hasResult = true; *hasResultType = true; break;
-    case Op::OpUGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
-    case Op::OpULessThan: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSLessThan: *hasResult = true; *hasResultType = true; break;
-    case Op::OpULessThanEqual: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSLessThanEqual: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFOrdEqual: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFUnordEqual: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFOrdNotEqual: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFUnordNotEqual: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFOrdLessThan: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFUnordLessThan: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFOrdGreaterThan: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFUnordGreaterThan: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFOrdLessThanEqual: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFUnordLessThanEqual: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFOrdGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFUnordGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
-    case Op::OpShiftRightLogical: *hasResult = true; *hasResultType = true; break;
-    case Op::OpShiftRightArithmetic: *hasResult = true; *hasResultType = true; break;
-    case Op::OpShiftLeftLogical: *hasResult = true; *hasResultType = true; break;
-    case Op::OpBitwiseOr: *hasResult = true; *hasResultType = true; break;
-    case Op::OpBitwiseXor: *hasResult = true; *hasResultType = true; break;
-    case Op::OpBitwiseAnd: *hasResult = true; *hasResultType = true; break;
-    case Op::OpNot: *hasResult = true; *hasResultType = true; break;
-    case Op::OpBitFieldInsert: *hasResult = true; *hasResultType = true; break;
-    case Op::OpBitFieldSExtract: *hasResult = true; *hasResultType = true; break;
-    case Op::OpBitFieldUExtract: *hasResult = true; *hasResultType = true; break;
-    case Op::OpBitReverse: *hasResult = true; *hasResultType = true; break;
-    case Op::OpBitCount: *hasResult = true; *hasResultType = true; break;
-    case Op::OpDPdx: *hasResult = true; *hasResultType = true; break;
-    case Op::OpDPdy: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFwidth: *hasResult = true; *hasResultType = true; break;
-    case Op::OpDPdxFine: *hasResult = true; *hasResultType = true; break;
-    case Op::OpDPdyFine: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFwidthFine: *hasResult = true; *hasResultType = true; break;
-    case Op::OpDPdxCoarse: *hasResult = true; *hasResultType = true; break;
-    case Op::OpDPdyCoarse: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFwidthCoarse: *hasResult = true; *hasResultType = true; break;
-    case Op::OpEmitVertex: *hasResult = false; *hasResultType = false; break;
-    case Op::OpEndPrimitive: *hasResult = false; *hasResultType = false; break;
-    case Op::OpEmitStreamVertex: *hasResult = false; *hasResultType = false; break;
-    case Op::OpEndStreamPrimitive: *hasResult = false; *hasResultType = false; break;
-    case Op::OpControlBarrier: *hasResult = false; *hasResultType = false; break;
-    case Op::OpMemoryBarrier: *hasResult = false; *hasResultType = false; break;
-    case Op::OpAtomicLoad: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAtomicStore: *hasResult = false; *hasResultType = false; break;
-    case Op::OpAtomicExchange: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAtomicCompareExchange: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAtomicCompareExchangeWeak: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAtomicIIncrement: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAtomicIDecrement: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAtomicIAdd: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAtomicISub: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAtomicSMin: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAtomicUMin: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAtomicSMax: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAtomicUMax: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAtomicAnd: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAtomicOr: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAtomicXor: *hasResult = true; *hasResultType = true; break;
-    case Op::OpPhi: *hasResult = true; *hasResultType = true; break;
-    case Op::OpLoopMerge: *hasResult = false; *hasResultType = false; break;
-    case Op::OpSelectionMerge: *hasResult = false; *hasResultType = false; break;
-    case Op::OpLabel: *hasResult = true; *hasResultType = false; break;
-    case Op::OpBranch: *hasResult = false; *hasResultType = false; break;
-    case Op::OpBranchConditional: *hasResult = false; *hasResultType = false; break;
-    case Op::OpSwitch: *hasResult = false; *hasResultType = false; break;
-    case Op::OpKill: *hasResult = false; *hasResultType = false; break;
-    case Op::OpReturn: *hasResult = false; *hasResultType = false; break;
-    case Op::OpReturnValue: *hasResult = false; *hasResultType = false; break;
-    case Op::OpUnreachable: *hasResult = false; *hasResultType = false; break;
-    case Op::OpLifetimeStart: *hasResult = false; *hasResultType = false; break;
-    case Op::OpLifetimeStop: *hasResult = false; *hasResultType = false; break;
-    case Op::OpGroupAsyncCopy: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupWaitEvents: *hasResult = false; *hasResultType = false; break;
-    case Op::OpGroupAll: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupAny: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupBroadcast: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupIAdd: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupFAdd: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupFMin: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupUMin: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupSMin: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupFMax: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupUMax: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupSMax: *hasResult = true; *hasResultType = true; break;
-    case Op::OpReadPipe: *hasResult = true; *hasResultType = true; break;
-    case Op::OpWritePipe: *hasResult = true; *hasResultType = true; break;
-    case Op::OpReservedReadPipe: *hasResult = true; *hasResultType = true; break;
-    case Op::OpReservedWritePipe: *hasResult = true; *hasResultType = true; break;
-    case Op::OpReserveReadPipePackets: *hasResult = true; *hasResultType = true; break;
-    case Op::OpReserveWritePipePackets: *hasResult = true; *hasResultType = true; break;
-    case Op::OpCommitReadPipe: *hasResult = false; *hasResultType = false; break;
-    case Op::OpCommitWritePipe: *hasResult = false; *hasResultType = false; break;
-    case Op::OpIsValidReserveId: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGetNumPipePackets: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGetMaxPipePackets: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupReserveReadPipePackets: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupReserveWritePipePackets: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupCommitReadPipe: *hasResult = false; *hasResultType = false; break;
-    case Op::OpGroupCommitWritePipe: *hasResult = false; *hasResultType = false; break;
-    case Op::OpEnqueueMarker: *hasResult = true; *hasResultType = true; break;
-    case Op::OpEnqueueKernel: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGetKernelNDrangeSubGroupCount: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGetKernelNDrangeMaxSubGroupSize: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGetKernelWorkGroupSize: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGetKernelPreferredWorkGroupSizeMultiple: *hasResult = true; *hasResultType = true; break;
-    case Op::OpRetainEvent: *hasResult = false; *hasResultType = false; break;
-    case Op::OpReleaseEvent: *hasResult = false; *hasResultType = false; break;
-    case Op::OpCreateUserEvent: *hasResult = true; *hasResultType = true; break;
-    case Op::OpIsValidEvent: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSetUserEventStatus: *hasResult = false; *hasResultType = false; break;
-    case Op::OpCaptureEventProfilingInfo: *hasResult = false; *hasResultType = false; break;
-    case Op::OpGetDefaultQueue: *hasResult = true; *hasResultType = true; break;
-    case Op::OpBuildNDRange: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageSparseSampleImplicitLod: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageSparseSampleExplicitLod: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageSparseSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageSparseSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageSparseSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageSparseSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageSparseSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageSparseSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageSparseFetch: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageSparseGather: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageSparseDrefGather: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageSparseTexelsResident: *hasResult = true; *hasResultType = true; break;
-    case Op::OpNoLine: *hasResult = false; *hasResultType = false; break;
-    case Op::OpAtomicFlagTestAndSet: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAtomicFlagClear: *hasResult = false; *hasResultType = false; break;
-    case Op::OpImageSparseRead: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSizeOf: *hasResult = true; *hasResultType = true; break;
-    case Op::OpTypePipeStorage: *hasResult = true; *hasResultType = false; break;
-    case Op::OpConstantPipeStorage: *hasResult = true; *hasResultType = true; break;
-    case Op::OpCreatePipeFromPipeStorage: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGetKernelLocalSizeForSubgroupCount: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGetKernelMaxNumSubgroups: *hasResult = true; *hasResultType = true; break;
-    case Op::OpTypeNamedBarrier: *hasResult = true; *hasResultType = false; break;
-    case Op::OpNamedBarrierInitialize: *hasResult = true; *hasResultType = true; break;
-    case Op::OpMemoryNamedBarrier: *hasResult = false; *hasResultType = false; break;
-    case Op::OpModuleProcessed: *hasResult = false; *hasResultType = false; break;
-    case Op::OpExecutionModeId: *hasResult = false; *hasResultType = false; break;
-    case Op::OpDecorateId: *hasResult = false; *hasResultType = false; break;
-    case Op::OpGroupNonUniformElect: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformAll: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformAny: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformAllEqual: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformBroadcast: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformBroadcastFirst: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformBallot: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformInverseBallot: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformBallotBitExtract: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformBallotBitCount: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformBallotFindLSB: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformBallotFindMSB: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformShuffle: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformShuffleXor: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformShuffleUp: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformShuffleDown: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformIAdd: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformFAdd: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformIMul: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformFMul: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformSMin: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformUMin: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformFMin: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformSMax: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformUMax: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformFMax: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformBitwiseAnd: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformBitwiseOr: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformBitwiseXor: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformLogicalAnd: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformLogicalOr: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformLogicalXor: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformQuadBroadcast: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformQuadSwap: *hasResult = true; *hasResultType = true; break;
-    case Op::OpCopyLogical: *hasResult = true; *hasResultType = true; break;
-    case Op::OpPtrEqual: *hasResult = true; *hasResultType = true; break;
-    case Op::OpPtrNotEqual: *hasResult = true; *hasResultType = true; break;
-    case Op::OpPtrDiff: *hasResult = true; *hasResultType = true; break;
-    case Op::OpColorAttachmentReadEXT: *hasResult = true; *hasResultType = true; break;
-    case Op::OpDepthAttachmentReadEXT: *hasResult = true; *hasResultType = true; break;
-    case Op::OpStencilAttachmentReadEXT: *hasResult = true; *hasResultType = true; break;
-    case Op::OpTerminateInvocation: *hasResult = false; *hasResultType = false; break;
-    case Op::OpSubgroupBallotKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupFirstInvocationKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAllKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAnyKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupNonUniformRotateKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpTraceRayKHR: *hasResult = false; *hasResultType = false; break;
-    case Op::OpExecuteCallableKHR: *hasResult = false; *hasResultType = false; break;
-    case Op::OpConvertUToAccelerationStructureKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpIgnoreIntersectionKHR: *hasResult = false; *hasResultType = false; break;
-    case Op::OpTerminateRayKHR: *hasResult = false; *hasResultType = false; break;
-    case Op::OpSDot: *hasResult = true; *hasResultType = true; break;
-    case Op::OpUDot: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSUDot: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSDotAccSat: *hasResult = true; *hasResultType = true; break;
-    case Op::OpUDotAccSat: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSUDotAccSat: *hasResult = true; *hasResultType = true; break;
-    case Op::OpTypeRayQueryKHR: *hasResult = true; *hasResultType = false; break;
-    case Op::OpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break;
-    case Op::OpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break;
-    case Op::OpRayQueryGenerateIntersectionKHR: *hasResult = false; *hasResultType = false; break;
-    case Op::OpRayQueryConfirmIntersectionKHR: *hasResult = false; *hasResultType = false; break;
-    case Op::OpRayQueryProceedKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpRayQueryGetIntersectionTypeKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageSampleWeightedQCOM: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageBoxFilterQCOM: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageBlockMatchSSDQCOM: *hasResult = true; *hasResultType = true; break;
-    case Op::OpImageBlockMatchSADQCOM: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupIAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupFAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupFMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupUMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupSMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupFMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupUMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupSMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFragmentMaskFetchAMD: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFragmentFetchAMD: *hasResult = true; *hasResultType = true; break;
-    case Op::OpReadClockKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpHitObjectRecordHitMotionNV: *hasResult = false; *hasResultType = false; break;
-    case Op::OpHitObjectRecordHitWithIndexMotionNV: *hasResult = false; *hasResultType = false; break;
-    case Op::OpHitObjectRecordMissMotionNV: *hasResult = false; *hasResultType = false; break;
-    case Op::OpHitObjectGetWorldToObjectNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpHitObjectGetObjectToWorldNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpHitObjectGetObjectRayDirectionNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpHitObjectGetObjectRayOriginNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpHitObjectTraceRayMotionNV: *hasResult = false; *hasResultType = false; break;
-    case Op::OpHitObjectGetShaderRecordBufferHandleNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpHitObjectGetShaderBindingTableRecordIndexNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpHitObjectRecordEmptyNV: *hasResult = false; *hasResultType = false; break;
-    case Op::OpHitObjectTraceRayNV: *hasResult = false; *hasResultType = false; break;
-    case Op::OpHitObjectRecordHitNV: *hasResult = false; *hasResultType = false; break;
-    case Op::OpHitObjectRecordHitWithIndexNV: *hasResult = false; *hasResultType = false; break;
-    case Op::OpHitObjectRecordMissNV: *hasResult = false; *hasResultType = false; break;
-    case Op::OpHitObjectExecuteShaderNV: *hasResult = false; *hasResultType = false; break;
-    case Op::OpHitObjectGetCurrentTimeNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpHitObjectGetAttributesNV: *hasResult = false; *hasResultType = false; break;
-    case Op::OpHitObjectGetHitKindNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpHitObjectGetPrimitiveIndexNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpHitObjectGetGeometryIndexNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpHitObjectGetInstanceIdNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpHitObjectGetInstanceCustomIndexNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpHitObjectGetWorldRayDirectionNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpHitObjectGetWorldRayOriginNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpHitObjectGetRayTMaxNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpHitObjectGetRayTMinNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpHitObjectIsEmptyNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpHitObjectIsHitNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpHitObjectIsMissNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpReorderThreadWithHitObjectNV: *hasResult = false; *hasResultType = false; break;
-    case Op::OpReorderThreadWithHintNV: *hasResult = false; *hasResultType = false; break;
-    case Op::OpTypeHitObjectNV: *hasResult = true; *hasResultType = false; break;
-    case Op::OpImageSampleFootprintNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpEmitMeshTasksEXT: *hasResult = false; *hasResultType = false; break;
-    case Op::OpSetMeshOutputsEXT: *hasResult = false; *hasResultType = false; break;
-    case Op::OpGroupNonUniformPartitionNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break;
-    case Op::OpReportIntersectionNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break;
-    case Op::OpTerminateRayNV: *hasResult = false; *hasResultType = false; break;
-    case Op::OpTraceNV: *hasResult = false; *hasResultType = false; break;
-    case Op::OpTraceMotionNV: *hasResult = false; *hasResultType = false; break;
-    case Op::OpTraceRayMotionNV: *hasResult = false; *hasResultType = false; break;
-    case Op::OpRayQueryGetIntersectionTriangleVertexPositionsKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpTypeAccelerationStructureNV: *hasResult = true; *hasResultType = false; break;
-    case Op::OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break;
-    case Op::OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break;
-    case Op::OpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpCooperativeMatrixStoreNV: *hasResult = false; *hasResultType = false; break;
-    case Op::OpCooperativeMatrixMulAddNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpCooperativeMatrixLengthNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpBeginInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break;
-    case Op::OpEndInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break;
-    case Op::OpDemoteToHelperInvocation: *hasResult = false; *hasResultType = false; break;
-    case Op::OpIsHelperInvocationEXT: *hasResult = true; *hasResultType = true; break;
-    case Op::OpConvertUToImageNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpConvertUToSamplerNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpConvertImageToUNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpConvertSamplerToUNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpConvertUToSampledImageNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpConvertSampledImageToUNV: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSamplerImageAddressingModeNV: *hasResult = false; *hasResultType = false; break;
-    case Op::OpSubgroupShuffleINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupShuffleDownINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupShuffleUpINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupShuffleXorINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
-    case Op::OpSubgroupImageBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupImageBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
-    case Op::OpSubgroupImageMediaBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupImageMediaBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
-    case Op::OpUCountLeadingZerosINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpUCountTrailingZerosINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAbsISubINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAbsUSubINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpIAddSatINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpUAddSatINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpIAverageINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpUAverageINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpIAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpUAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpISubSatINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpUSubSatINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpIMul32x16INTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpUMul32x16INTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpConstantFunctionPointerINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFunctionPointerCallINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAsmTargetINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAsmINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAsmCallINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAtomicFMinEXT: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAtomicFMaxEXT: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAssumeTrueKHR: *hasResult = false; *hasResultType = false; break;
-    case Op::OpExpectKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpDecorateString: *hasResult = false; *hasResultType = false; break;
-    case Op::OpMemberDecorateString: *hasResult = false; *hasResultType = false; break;
-    case Op::OpVmeImageINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpTypeVmeImageINTEL: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeAvcImePayloadINTEL: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeAvcRefPayloadINTEL: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeAvcSicPayloadINTEL: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeAvcMcePayloadINTEL: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeAvcMceResultINTEL: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeAvcImeResultINTEL: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeAvcImeResultSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeAvcImeResultDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeAvcImeSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeAvcImeDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeAvcRefResultINTEL: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeAvcSicResultINTEL: *hasResult = true; *hasResultType = false; break;
-    case Op::OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceSetInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceSetInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceSetAcOnlyHaarINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceConvertToImePayloadINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceConvertToImeResultINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceConvertToRefPayloadINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceConvertToRefResultINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceConvertToSicPayloadINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceConvertToSicResultINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceGetMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceGetInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceGetBestInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceGetInterMajorShapeINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceGetInterMinorShapeINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceGetInterDirectionsINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceGetInterMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceGetInterReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeSetSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeSetDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeRefWindowSizeINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeAdjustRefOffsetINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeSetMaxMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeSetWeightedSadINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeGetSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeGetDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeStripDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeGetBorderReachedINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcFmeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcBmeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcRefConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcRefSetBidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcRefSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcRefEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcRefConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicInitializeINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicConfigureSkcINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicConfigureIpeLumaINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicConfigureIpeLumaChromaINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicGetMotionVectorMaskINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicEvaluateIpeINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicGetIpeLumaShapeINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicGetPackedIpeLumaModesINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicGetIpeChromaModeINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSubgroupAvcSicGetInterRawSadsINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpVariableLengthArrayINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpSaveMemoryINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpRestoreMemoryINTEL: *hasResult = false; *hasResultType = false; break;
-    case Op::OpArbitraryFloatSinCosPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatCastINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatCastFromIntINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatCastToIntINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatAddINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatSubINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatMulINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatDivINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatGTINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatGEINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatLTINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatLEINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatEQINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatRecipINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatRSqrtINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatCbrtINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatHypotINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatSqrtINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatLogINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatLog2INTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatLog10INTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatLog1pINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatExpINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatExp2INTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatExp10INTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatExpm1INTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatSinINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatCosINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatSinCosINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatSinPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatCosPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatASinINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatASinPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatACosINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatACosPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatATanINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatATanPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatATan2INTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatPowINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatPowRINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpArbitraryFloatPowNINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpLoopControlINTEL: *hasResult = false; *hasResultType = false; break;
-    case Op::OpAliasDomainDeclINTEL: *hasResult = true; *hasResultType = false; break;
-    case Op::OpAliasScopeDeclINTEL: *hasResult = true; *hasResultType = false; break;
-    case Op::OpAliasScopeListDeclINTEL: *hasResult = true; *hasResultType = false; break;
-    case Op::OpFixedSqrtINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFixedRecipINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFixedRsqrtINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFixedSinINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFixedCosINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFixedSinCosINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFixedSinPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFixedCosPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFixedSinCosPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFixedLogINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFixedExpINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpPtrCastToCrossWorkgroupINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpCrossWorkgroupCastToPtrINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpReadPipeBlockingINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpWritePipeBlockingINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpFPGARegINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpRayQueryGetRayTMinKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpRayQueryGetRayFlagsKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpRayQueryGetIntersectionTKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpRayQueryGetIntersectionInstanceCustomIndexKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpRayQueryGetIntersectionInstanceIdKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpRayQueryGetIntersectionGeometryIndexKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpRayQueryGetIntersectionPrimitiveIndexKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpRayQueryGetIntersectionBarycentricsKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpRayQueryGetIntersectionFrontFaceKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpRayQueryGetIntersectionObjectRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpRayQueryGetIntersectionObjectRayOriginKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpRayQueryGetWorldRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpRayQueryGetWorldRayOriginKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpAtomicFAddEXT: *hasResult = true; *hasResultType = true; break;
-    case Op::OpTypeBufferSurfaceINTEL: *hasResult = true; *hasResultType = false; break;
-    case Op::OpTypeStructContinuedINTEL: *hasResult = false; *hasResultType = false; break;
-    case Op::OpConstantCompositeContinuedINTEL: *hasResult = false; *hasResultType = false; break;
-    case Op::OpSpecConstantCompositeContinuedINTEL: *hasResult = false; *hasResultType = false; break;
-    case Op::OpConvertFToBF16INTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpConvertBF16ToFINTEL: *hasResult = true; *hasResultType = true; break;
-    case Op::OpControlBarrierArriveINTEL: *hasResult = false; *hasResultType = false; break;
-    case Op::OpControlBarrierWaitINTEL: *hasResult = false; *hasResultType = false; break;
-    case Op::OpGroupIMulKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupFMulKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupBitwiseAndKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupBitwiseOrKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupBitwiseXorKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupLogicalAndKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupLogicalOrKHR: *hasResult = true; *hasResultType = true; break;
-    case Op::OpGroupLogicalXorKHR: *hasResult = true; *hasResultType = true; break;
-    }
+  *hasResult = *hasResultType = false;
+  switch (opcode) {
+  default: /* unknown opcode */
+    break;
+  case Op::OpNop:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpUndef:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSourceContinued:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpSource:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpSourceExtension:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpName:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpMemberName:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpString:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpLine:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpExtension:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpExtInstImport:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpExtInst:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpMemoryModel:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpEntryPoint:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpExecutionMode:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpCapability:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeVoid:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeBool:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeInt:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeFloat:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeVector:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeMatrix:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeImage:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeSampler:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeSampledImage:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeArray:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeRuntimeArray:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeStruct:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeOpaque:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypePointer:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeFunction:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeEvent:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeDeviceEvent:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeReserveId:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeQueue:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypePipe:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeForwardPointer:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpConstantTrue:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpConstantFalse:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpConstant:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpConstantComposite:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpConstantSampler:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpConstantNull:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSpecConstantTrue:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSpecConstantFalse:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSpecConstant:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSpecConstantComposite:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSpecConstantOp:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFunction:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFunctionParameter:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFunctionEnd:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpFunctionCall:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpVariable:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageTexelPointer:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpLoad:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpStore:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpCopyMemory:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpCopyMemorySized:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpAccessChain:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpInBoundsAccessChain:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpPtrAccessChain:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArrayLength:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGenericPtrMemSemantics:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpInBoundsPtrAccessChain:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpDecorate:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpMemberDecorate:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpDecorationGroup:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpGroupDecorate:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpGroupMemberDecorate:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpVectorExtractDynamic:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpVectorInsertDynamic:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpVectorShuffle:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpCompositeConstruct:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpCompositeExtract:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpCompositeInsert:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpCopyObject:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpTranspose:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSampledImage:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageSampleImplicitLod:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageSampleExplicitLod:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageSampleDrefImplicitLod:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageSampleDrefExplicitLod:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageSampleProjImplicitLod:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageSampleProjExplicitLod:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageSampleProjDrefImplicitLod:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageSampleProjDrefExplicitLod:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageFetch:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageGather:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageDrefGather:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageRead:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageWrite:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpImage:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageQueryFormat:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageQueryOrder:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageQuerySizeLod:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageQuerySize:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageQueryLod:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageQueryLevels:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageQuerySamples:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpConvertFToU:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpConvertFToS:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpConvertSToF:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpConvertUToF:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpUConvert:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSConvert:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFConvert:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpQuantizeToF16:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpConvertPtrToU:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSatConvertSToU:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSatConvertUToS:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpConvertUToPtr:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpPtrCastToGeneric:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGenericCastToPtr:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGenericCastToPtrExplicit:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpBitcast:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSNegate:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFNegate:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpIAdd:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFAdd:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpISub:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFSub:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpIMul:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFMul:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpUDiv:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSDiv:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFDiv:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpUMod:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSRem:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSMod:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFRem:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFMod:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpVectorTimesScalar:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpMatrixTimesScalar:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpVectorTimesMatrix:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpMatrixTimesVector:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpMatrixTimesMatrix:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpOuterProduct:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpDot:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpIAddCarry:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpISubBorrow:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpUMulExtended:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSMulExtended:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAny:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAll:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpIsNan:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpIsInf:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpIsFinite:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpIsNormal:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSignBitSet:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpLessOrGreater:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpOrdered:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpUnordered:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpLogicalEqual:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpLogicalNotEqual:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpLogicalOr:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpLogicalAnd:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpLogicalNot:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSelect:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpIEqual:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpINotEqual:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpUGreaterThan:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSGreaterThan:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpUGreaterThanEqual:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSGreaterThanEqual:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpULessThan:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSLessThan:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpULessThanEqual:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSLessThanEqual:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFOrdEqual:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFUnordEqual:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFOrdNotEqual:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFUnordNotEqual:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFOrdLessThan:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFUnordLessThan:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFOrdGreaterThan:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFUnordGreaterThan:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFOrdLessThanEqual:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFUnordLessThanEqual:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFOrdGreaterThanEqual:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFUnordGreaterThanEqual:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpShiftRightLogical:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpShiftRightArithmetic:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpShiftLeftLogical:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpBitwiseOr:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpBitwiseXor:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpBitwiseAnd:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpNot:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpBitFieldInsert:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpBitFieldSExtract:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpBitFieldUExtract:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpBitReverse:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpBitCount:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpDPdx:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpDPdy:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFwidth:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpDPdxFine:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpDPdyFine:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFwidthFine:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpDPdxCoarse:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpDPdyCoarse:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFwidthCoarse:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpEmitVertex:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpEndPrimitive:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpEmitStreamVertex:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpEndStreamPrimitive:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpControlBarrier:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpMemoryBarrier:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpAtomicLoad:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAtomicStore:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpAtomicExchange:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAtomicCompareExchange:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAtomicCompareExchangeWeak:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAtomicIIncrement:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAtomicIDecrement:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAtomicIAdd:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAtomicISub:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAtomicSMin:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAtomicUMin:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAtomicSMax:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAtomicUMax:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAtomicAnd:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAtomicOr:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAtomicXor:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpPhi:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpLoopMerge:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpSelectionMerge:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpLabel:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpBranch:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpBranchConditional:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpSwitch:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpKill:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpReturn:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpReturnValue:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpUnreachable:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpLifetimeStart:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpLifetimeStop:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpGroupAsyncCopy:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupWaitEvents:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpGroupAll:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupAny:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupBroadcast:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupIAdd:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupFAdd:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupFMin:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupUMin:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupSMin:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupFMax:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupUMax:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupSMax:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpReadPipe:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpWritePipe:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpReservedReadPipe:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpReservedWritePipe:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpReserveReadPipePackets:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpReserveWritePipePackets:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpCommitReadPipe:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpCommitWritePipe:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpIsValidReserveId:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGetNumPipePackets:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGetMaxPipePackets:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupReserveReadPipePackets:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupReserveWritePipePackets:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupCommitReadPipe:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpGroupCommitWritePipe:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpEnqueueMarker:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpEnqueueKernel:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGetKernelNDrangeSubGroupCount:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGetKernelNDrangeMaxSubGroupSize:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGetKernelWorkGroupSize:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGetKernelPreferredWorkGroupSizeMultiple:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpRetainEvent:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpReleaseEvent:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpCreateUserEvent:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpIsValidEvent:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSetUserEventStatus:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpCaptureEventProfilingInfo:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpGetDefaultQueue:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpBuildNDRange:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageSparseSampleImplicitLod:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageSparseSampleExplicitLod:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageSparseSampleDrefImplicitLod:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageSparseSampleDrefExplicitLod:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageSparseSampleProjImplicitLod:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageSparseSampleProjExplicitLod:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageSparseSampleProjDrefImplicitLod:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageSparseSampleProjDrefExplicitLod:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageSparseFetch:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageSparseGather:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageSparseDrefGather:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageSparseTexelsResident:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpNoLine:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpAtomicFlagTestAndSet:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAtomicFlagClear:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpImageSparseRead:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSizeOf:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpTypePipeStorage:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpConstantPipeStorage:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpCreatePipeFromPipeStorage:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGetKernelLocalSizeForSubgroupCount:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGetKernelMaxNumSubgroups:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpTypeNamedBarrier:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpNamedBarrierInitialize:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpMemoryNamedBarrier:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpModuleProcessed:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpExecutionModeId:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpDecorateId:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpGroupNonUniformElect:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformAll:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformAny:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformAllEqual:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformBroadcast:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformBroadcastFirst:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformBallot:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformInverseBallot:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformBallotBitExtract:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformBallotBitCount:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformBallotFindLSB:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformBallotFindMSB:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformShuffle:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformShuffleXor:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformShuffleUp:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformShuffleDown:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformIAdd:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformFAdd:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformIMul:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformFMul:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformSMin:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformUMin:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformFMin:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformSMax:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformUMax:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformFMax:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformBitwiseAnd:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformBitwiseOr:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformBitwiseXor:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformLogicalAnd:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformLogicalOr:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformLogicalXor:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformQuadBroadcast:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformQuadSwap:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpCopyLogical:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpPtrEqual:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpPtrNotEqual:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpPtrDiff:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpColorAttachmentReadEXT:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpDepthAttachmentReadEXT:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpStencilAttachmentReadEXT:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpTerminateInvocation:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpSubgroupBallotKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupFirstInvocationKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAllKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAnyKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAllEqualKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupNonUniformRotateKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupReadInvocationKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpTraceRayKHR:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpExecuteCallableKHR:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpConvertUToAccelerationStructureKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpIgnoreIntersectionKHR:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpTerminateRayKHR:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpSDot:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpUDot:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSUDot:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSDotAccSat:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpUDotAccSat:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSUDotAccSat:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpTypeRayQueryKHR:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpRayQueryInitializeKHR:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpRayQueryTerminateKHR:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpRayQueryGenerateIntersectionKHR:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpRayQueryConfirmIntersectionKHR:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpRayQueryProceedKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpRayQueryGetIntersectionTypeKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageSampleWeightedQCOM:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageBoxFilterQCOM:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageBlockMatchSSDQCOM:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpImageBlockMatchSADQCOM:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupIAddNonUniformAMD:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupFAddNonUniformAMD:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupFMinNonUniformAMD:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupUMinNonUniformAMD:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupSMinNonUniformAMD:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupFMaxNonUniformAMD:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupUMaxNonUniformAMD:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupSMaxNonUniformAMD:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFragmentMaskFetchAMD:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFragmentFetchAMD:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpReadClockKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpHitObjectRecordHitMotionNV:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpHitObjectRecordHitWithIndexMotionNV:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpHitObjectRecordMissMotionNV:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpHitObjectGetWorldToObjectNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpHitObjectGetObjectToWorldNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpHitObjectGetObjectRayDirectionNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpHitObjectGetObjectRayOriginNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpHitObjectTraceRayMotionNV:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpHitObjectGetShaderRecordBufferHandleNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpHitObjectGetShaderBindingTableRecordIndexNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpHitObjectRecordEmptyNV:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpHitObjectTraceRayNV:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpHitObjectRecordHitNV:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpHitObjectRecordHitWithIndexNV:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpHitObjectRecordMissNV:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpHitObjectExecuteShaderNV:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpHitObjectGetCurrentTimeNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpHitObjectGetAttributesNV:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpHitObjectGetHitKindNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpHitObjectGetPrimitiveIndexNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpHitObjectGetGeometryIndexNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpHitObjectGetInstanceIdNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpHitObjectGetInstanceCustomIndexNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpHitObjectGetWorldRayDirectionNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpHitObjectGetWorldRayOriginNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpHitObjectGetRayTMaxNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpHitObjectGetRayTMinNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpHitObjectIsEmptyNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpHitObjectIsHitNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpHitObjectIsMissNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpReorderThreadWithHitObjectNV:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpReorderThreadWithHintNV:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeHitObjectNV:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpImageSampleFootprintNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpEmitMeshTasksEXT:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpSetMeshOutputsEXT:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpGroupNonUniformPartitionNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpWritePackedPrimitiveIndices4x8NV:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpReportIntersectionNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpIgnoreIntersectionNV:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpTerminateRayNV:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpTraceNV:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpTraceMotionNV:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpTraceRayMotionNV:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpRayQueryGetIntersectionTriangleVertexPositionsKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpTypeAccelerationStructureNV:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpExecuteCallableNV:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeCooperativeMatrixNV:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpCooperativeMatrixLoadNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpCooperativeMatrixStoreNV:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpCooperativeMatrixMulAddNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpCooperativeMatrixLengthNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpBeginInvocationInterlockEXT:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpEndInvocationInterlockEXT:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpDemoteToHelperInvocation:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpIsHelperInvocationEXT:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpConvertUToImageNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpConvertUToSamplerNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpConvertImageToUNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpConvertSamplerToUNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpConvertUToSampledImageNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpConvertSampledImageToUNV:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSamplerImageAddressingModeNV:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpSubgroupShuffleINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupShuffleDownINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupShuffleUpINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupShuffleXorINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupBlockReadINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupBlockWriteINTEL:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpSubgroupImageBlockReadINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupImageBlockWriteINTEL:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpSubgroupImageMediaBlockReadINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupImageMediaBlockWriteINTEL:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpUCountLeadingZerosINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpUCountTrailingZerosINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAbsISubINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAbsUSubINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpIAddSatINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpUAddSatINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpIAverageINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpUAverageINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpIAverageRoundedINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpUAverageRoundedINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpISubSatINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpUSubSatINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpIMul32x16INTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpUMul32x16INTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpConstantFunctionPointerINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFunctionPointerCallINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAsmTargetINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAsmINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAsmCallINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAtomicFMinEXT:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAtomicFMaxEXT:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAssumeTrueKHR:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpExpectKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpDecorateString:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpMemberDecorateString:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpVmeImageINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpTypeVmeImageINTEL:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeAvcImePayloadINTEL:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeAvcRefPayloadINTEL:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeAvcSicPayloadINTEL:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeAvcMcePayloadINTEL:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeAvcMceResultINTEL:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeAvcImeResultINTEL:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeAvcImeResultSingleReferenceStreamoutINTEL:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeAvcImeResultDualReferenceStreamoutINTEL:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeAvcImeSingleReferenceStreaminINTEL:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeAvcImeDualReferenceStreaminINTEL:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeAvcRefResultINTEL:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeAvcSicResultINTEL:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceSetInterShapePenaltyINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceSetInterDirectionPenaltyINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceSetAcOnlyHaarINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceConvertToImePayloadINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceConvertToImeResultINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceConvertToRefPayloadINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceConvertToRefResultINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceConvertToSicPayloadINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceConvertToSicResultINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceGetMotionVectorsINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceGetInterDistortionsINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceGetBestInterDistortionsINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceGetInterMajorShapeINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceGetInterMinorShapeINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceGetInterDirectionsINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceGetInterMotionVectorCountINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceGetInterReferenceIdsINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeInitializeINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeSetSingleReferenceINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeSetDualReferenceINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeRefWindowSizeINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeAdjustRefOffsetINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeConvertToMcePayloadINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeSetMaxMotionVectorCountINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeSetWeightedSadINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeEvaluateWithDualReferenceINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeConvertToMceResultINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeGetSingleReferenceStreaminINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeGetDualReferenceStreaminINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeStripDualReferenceStreamoutINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::
+      OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::
+      OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::
+      OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::
+      OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeGetBorderReachedINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcFmeInitializeINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcBmeInitializeINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcRefConvertToMcePayloadINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcRefSetBidirectionalMixDisableINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcRefSetBilinearFilterEnableINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcRefEvaluateWithDualReferenceINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcRefConvertToMceResultINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicInitializeINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicConfigureSkcINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicConfigureIpeLumaINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicConfigureIpeLumaChromaINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicGetMotionVectorMaskINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicConvertToMcePayloadINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicSetBilinearFilterEnableINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicEvaluateIpeINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicEvaluateWithDualReferenceINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicConvertToMceResultINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicGetIpeLumaShapeINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicGetPackedIpeLumaModesINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicGetIpeChromaModeINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSubgroupAvcSicGetInterRawSadsINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpVariableLengthArrayINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpSaveMemoryINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpRestoreMemoryINTEL:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpArbitraryFloatSinCosPiINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatCastINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatCastFromIntINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatCastToIntINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatAddINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatSubINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatMulINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatDivINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatGTINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatGEINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatLTINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatLEINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatEQINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatRecipINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatRSqrtINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatCbrtINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatHypotINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatSqrtINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatLogINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatLog2INTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatLog10INTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatLog1pINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatExpINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatExp2INTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatExp10INTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatExpm1INTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatSinINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatCosINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatSinCosINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatSinPiINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatCosPiINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatASinINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatASinPiINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatACosINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatACosPiINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatATanINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatATanPiINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatATan2INTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatPowINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatPowRINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpArbitraryFloatPowNINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpLoopControlINTEL:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpAliasDomainDeclINTEL:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpAliasScopeDeclINTEL:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpAliasScopeListDeclINTEL:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpFixedSqrtINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFixedRecipINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFixedRsqrtINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFixedSinINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFixedCosINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFixedSinCosINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFixedSinPiINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFixedCosPiINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFixedSinCosPiINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFixedLogINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFixedExpINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpPtrCastToCrossWorkgroupINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpCrossWorkgroupCastToPtrINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpReadPipeBlockingINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpWritePipeBlockingINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpFPGARegINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpRayQueryGetRayTMinKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpRayQueryGetRayFlagsKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpRayQueryGetIntersectionTKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpRayQueryGetIntersectionInstanceCustomIndexKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpRayQueryGetIntersectionInstanceIdKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpRayQueryGetIntersectionGeometryIndexKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpRayQueryGetIntersectionPrimitiveIndexKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpRayQueryGetIntersectionBarycentricsKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpRayQueryGetIntersectionFrontFaceKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpRayQueryGetIntersectionCandidateAABBOpaqueKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpRayQueryGetIntersectionObjectRayDirectionKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpRayQueryGetIntersectionObjectRayOriginKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpRayQueryGetWorldRayDirectionKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpRayQueryGetWorldRayOriginKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpRayQueryGetIntersectionObjectToWorldKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpRayQueryGetIntersectionWorldToObjectKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpAtomicFAddEXT:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpTypeBufferSurfaceINTEL:
+    *hasResult = true;
+    *hasResultType = false;
+    break;
+  case Op::OpTypeStructContinuedINTEL:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpConstantCompositeContinuedINTEL:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpSpecConstantCompositeContinuedINTEL:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpConvertFToBF16INTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpConvertBF16ToFINTEL:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpControlBarrierArriveINTEL:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpControlBarrierWaitINTEL:
+    *hasResult = false;
+    *hasResultType = false;
+    break;
+  case Op::OpGroupIMulKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupFMulKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupBitwiseAndKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupBitwiseOrKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupBitwiseXorKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupLogicalAndKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupLogicalOrKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  case Op::OpGroupLogicalXorKHR:
+    *hasResult = true;
+    *hasResultType = true;
+    break;
+  }
 }
 #endif /* SPV_ENABLE_UTILITY_CODE */
 
 // Overload bitwise operators for mask bit combining
 
-constexpr ImageOperandsMask operator|(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) | unsigned(b)); }
-constexpr ImageOperandsMask operator&(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) & unsigned(b)); }
-constexpr ImageOperandsMask operator^(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) ^ unsigned(b)); }
-constexpr ImageOperandsMask operator~(ImageOperandsMask a) { return ImageOperandsMask(~unsigned(a)); }
-constexpr FPFastMathModeMask operator|(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) | unsigned(b)); }
-constexpr FPFastMathModeMask operator&(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) & unsigned(b)); }
-constexpr FPFastMathModeMask operator^(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) ^ unsigned(b)); }
-constexpr FPFastMathModeMask operator~(FPFastMathModeMask a) { return FPFastMathModeMask(~unsigned(a)); }
-constexpr SelectionControlMask operator|(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) | unsigned(b)); }
-constexpr SelectionControlMask operator&(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) & unsigned(b)); }
-constexpr SelectionControlMask operator^(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) ^ unsigned(b)); }
-constexpr SelectionControlMask operator~(SelectionControlMask a) { return SelectionControlMask(~unsigned(a)); }
-constexpr LoopControlMask operator|(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) | unsigned(b)); }
-constexpr LoopControlMask operator&(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) & unsigned(b)); }
-constexpr LoopControlMask operator^(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) ^ unsigned(b)); }
-constexpr LoopControlMask operator~(LoopControlMask a) { return LoopControlMask(~unsigned(a)); }
-constexpr FunctionControlMask operator|(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) | unsigned(b)); }
-constexpr FunctionControlMask operator&(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) & unsigned(b)); }
-constexpr FunctionControlMask operator^(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) ^ unsigned(b)); }
-constexpr FunctionControlMask operator~(FunctionControlMask a) { return FunctionControlMask(~unsigned(a)); }
-constexpr MemorySemanticsMask operator|(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) | unsigned(b)); }
-constexpr MemorySemanticsMask operator&(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) & unsigned(b)); }
-constexpr MemorySemanticsMask operator^(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) ^ unsigned(b)); }
-constexpr MemorySemanticsMask operator~(MemorySemanticsMask a) { return MemorySemanticsMask(~unsigned(a)); }
-constexpr MemoryAccessMask operator|(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) | unsigned(b)); }
-constexpr MemoryAccessMask operator&(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) & unsigned(b)); }
-constexpr MemoryAccessMask operator^(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) ^ unsigned(b)); }
-constexpr MemoryAccessMask operator~(MemoryAccessMask a) { return MemoryAccessMask(~unsigned(a)); }
-constexpr KernelProfilingInfoMask operator|(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) | unsigned(b)); }
-constexpr KernelProfilingInfoMask operator&(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) & unsigned(b)); }
-constexpr KernelProfilingInfoMask operator^(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) ^ unsigned(b)); }
-constexpr KernelProfilingInfoMask operator~(KernelProfilingInfoMask a) { return KernelProfilingInfoMask(~unsigned(a)); }
-constexpr RayFlagsMask operator|(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) | unsigned(b)); }
-constexpr RayFlagsMask operator&(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) & unsigned(b)); }
-constexpr RayFlagsMask operator^(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) ^ unsigned(b)); }
-constexpr RayFlagsMask operator~(RayFlagsMask a) { return RayFlagsMask(~unsigned(a)); }
-constexpr FragmentShadingRateMask operator|(FragmentShadingRateMask a, FragmentShadingRateMask b) { return FragmentShadingRateMask(unsigned(a) | unsigned(b)); }
-constexpr FragmentShadingRateMask operator&(FragmentShadingRateMask a, FragmentShadingRateMask b) { return FragmentShadingRateMask(unsigned(a) & unsigned(b)); }
-constexpr FragmentShadingRateMask operator^(FragmentShadingRateMask a, FragmentShadingRateMask b) { return FragmentShadingRateMask(unsigned(a) ^ unsigned(b)); }
-constexpr FragmentShadingRateMask operator~(FragmentShadingRateMask a) { return FragmentShadingRateMask(~unsigned(a)); }
+constexpr ImageOperandsMask operator|(ImageOperandsMask a,
+                                      ImageOperandsMask b) {
+  return ImageOperandsMask(unsigned(a) | unsigned(b));
+}
+constexpr ImageOperandsMask operator&(ImageOperandsMask a,
+                                      ImageOperandsMask b) {
+  return ImageOperandsMask(unsigned(a) & unsigned(b));
+}
+constexpr ImageOperandsMask operator^(ImageOperandsMask a,
+                                      ImageOperandsMask b) {
+  return ImageOperandsMask(unsigned(a) ^ unsigned(b));
+}
+constexpr ImageOperandsMask operator~(ImageOperandsMask a) {
+  return ImageOperandsMask(~unsigned(a));
+}
+constexpr FPFastMathModeMask operator|(FPFastMathModeMask a,
+                                       FPFastMathModeMask b) {
+  return FPFastMathModeMask(unsigned(a) | unsigned(b));
+}
+constexpr FPFastMathModeMask operator&(FPFastMathModeMask a,
+                                       FPFastMathModeMask b) {
+  return FPFastMathModeMask(unsigned(a) & unsigned(b));
+}
+constexpr FPFastMathModeMask operator^(FPFastMathModeMask a,
+                                       FPFastMathModeMask b) {
+  return FPFastMathModeMask(unsigned(a) ^ unsigned(b));
+}
+constexpr FPFastMathModeMask operator~(FPFastMathModeMask a) {
+  return FPFastMathModeMask(~unsigned(a));
+}
+constexpr SelectionControlMask operator|(SelectionControlMask a,
+                                         SelectionControlMask b) {
+  return SelectionControlMask(unsigned(a) | unsigned(b));
+}
+constexpr SelectionControlMask operator&(SelectionControlMask a,
+                                         SelectionControlMask b) {
+  return SelectionControlMask(unsigned(a) & unsigned(b));
+}
+constexpr SelectionControlMask operator^(SelectionControlMask a,
+                                         SelectionControlMask b) {
+  return SelectionControlMask(unsigned(a) ^ unsigned(b));
+}
+constexpr SelectionControlMask operator~(SelectionControlMask a) {
+  return SelectionControlMask(~unsigned(a));
+}
+constexpr LoopControlMask operator|(LoopControlMask a, LoopControlMask b) {
+  return LoopControlMask(unsigned(a) | unsigned(b));
+}
+constexpr LoopControlMask operator&(LoopControlMask a, LoopControlMask b) {
+  return LoopControlMask(unsigned(a) & unsigned(b));
+}
+constexpr LoopControlMask operator^(LoopControlMask a, LoopControlMask b) {
+  return LoopControlMask(unsigned(a) ^ unsigned(b));
+}
+constexpr LoopControlMask operator~(LoopControlMask a) {
+  return LoopControlMask(~unsigned(a));
+}
+constexpr FunctionControlMask operator|(FunctionControlMask a,
+                                        FunctionControlMask b) {
+  return FunctionControlMask(unsigned(a) | unsigned(b));
+}
+constexpr FunctionControlMask operator&(FunctionControlMask a,
+                                        FunctionControlMask b) {
+  return FunctionControlMask(unsigned(a) & unsigned(b));
+}
+constexpr FunctionControlMask operator^(FunctionControlMask a,
+                                        FunctionControlMask b) {
+  return FunctionControlMask(unsigned(a) ^ unsigned(b));
+}
+constexpr FunctionControlMask operator~(FunctionControlMask a) {
+  return FunctionControlMask(~unsigned(a));
+}
+constexpr MemorySemanticsMask operator|(MemorySemanticsMask a,
+                                        MemorySemanticsMask b) {
+  return MemorySemanticsMask(unsigned(a) | unsigned(b));
+}
+constexpr MemorySemanticsMask operator&(MemorySemanticsMask a,
+                                        MemorySemanticsMask b) {
+  return MemorySemanticsMask(unsigned(a) & unsigned(b));
+}
+constexpr MemorySemanticsMask operator^(MemorySemanticsMask a,
+                                        MemorySemanticsMask b) {
+  return MemorySemanticsMask(unsigned(a) ^ unsigned(b));
+}
+constexpr MemorySemanticsMask operator~(MemorySemanticsMask a) {
+  return MemorySemanticsMask(~unsigned(a));
+}
+constexpr MemoryAccessMask operator|(MemoryAccessMask a, MemoryAccessMask b) {
+  return MemoryAccessMask(unsigned(a) | unsigned(b));
+}
+constexpr MemoryAccessMask operator&(MemoryAccessMask a, MemoryAccessMask b) {
+  return MemoryAccessMask(unsigned(a) & unsigned(b));
+}
+constexpr MemoryAccessMask operator^(MemoryAccessMask a, MemoryAccessMask b) {
+  return MemoryAccessMask(unsigned(a) ^ unsigned(b));
+}
+constexpr MemoryAccessMask operator~(MemoryAccessMask a) {
+  return MemoryAccessMask(~unsigned(a));
+}
+constexpr KernelProfilingInfoMask operator|(KernelProfilingInfoMask a,
+                                            KernelProfilingInfoMask b) {
+  return KernelProfilingInfoMask(unsigned(a) | unsigned(b));
+}
+constexpr KernelProfilingInfoMask operator&(KernelProfilingInfoMask a,
+                                            KernelProfilingInfoMask b) {
+  return KernelProfilingInfoMask(unsigned(a) & unsigned(b));
+}
+constexpr KernelProfilingInfoMask operator^(KernelProfilingInfoMask a,
+                                            KernelProfilingInfoMask b) {
+  return KernelProfilingInfoMask(unsigned(a) ^ unsigned(b));
+}
+constexpr KernelProfilingInfoMask operator~(KernelProfilingInfoMask a) {
+  return KernelProfilingInfoMask(~unsigned(a));
+}
+constexpr RayFlagsMask operator|(RayFlagsMask a, RayFlagsMask b) {
+  return RayFlagsMask(unsigned(a) | unsigned(b));
+}
+constexpr RayFlagsMask operator&(RayFlagsMask a, RayFlagsMask b) {
+  return RayFlagsMask(unsigned(a) & unsigned(b));
+}
+constexpr RayFlagsMask operator^(RayFlagsMask a, RayFlagsMask b) {
+  return RayFlagsMask(unsigned(a) ^ unsigned(b));
+}
+constexpr RayFlagsMask operator~(RayFlagsMask a) {
+  return RayFlagsMask(~unsigned(a));
+}
+constexpr FragmentShadingRateMask operator|(FragmentShadingRateMask a,
+                                            FragmentShadingRateMask b) {
+  return FragmentShadingRateMask(unsigned(a) | unsigned(b));
+}
+constexpr FragmentShadingRateMask operator&(FragmentShadingRateMask a,
+                                            FragmentShadingRateMask b) {
+  return FragmentShadingRateMask(unsigned(a) & unsigned(b));
+}
+constexpr FragmentShadingRateMask operator^(FragmentShadingRateMask a,
+                                            FragmentShadingRateMask b) {
+  return FragmentShadingRateMask(unsigned(a) ^ unsigned(b));
+}
+constexpr FragmentShadingRateMask operator~(FragmentShadingRateMask a) {
+  return FragmentShadingRateMask(~unsigned(a));
+}
 
-}  // end namespace spv
-
-#endif  // #ifndef spirv_HPP
+} // end namespace spv
 
+#endif // #ifndef spirv_HPP
diff --git a/hw/amdgpu/shader/include/amdgpu/shader/Converter.hpp b/hw/amdgpu/shader/include/amdgpu/shader/Converter.hpp
index 817eed622..6c0af1c20 100644
--- a/hw/amdgpu/shader/include/amdgpu/shader/Converter.hpp
+++ b/hw/amdgpu/shader/include/amdgpu/shader/Converter.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
-#include "Stage.hpp"
 #include "AccessOp.hpp"
+#include "Stage.hpp"
 
 #include <amdgpu/RemoteMemory.hpp>
 
@@ -11,11 +11,7 @@
 
 namespace amdgpu::shader {
 struct Shader {
-  enum class UniformKind {
-    Buffer,
-    Sampler,
-    Image
-  };
+  enum class UniformKind { Buffer, Sampler, Image };
 
   struct UniformInfo {
     std::uint32_t binding;
diff --git a/hw/amdgpu/shader/include/amdgpu/shader/ConverterContext.hpp b/hw/amdgpu/shader/include/amdgpu/shader/ConverterContext.hpp
index c6707097b..6fd5fa941 100644
--- a/hw/amdgpu/shader/include/amdgpu/shader/ConverterContext.hpp
+++ b/hw/amdgpu/shader/include/amdgpu/shader/ConverterContext.hpp
@@ -9,18 +9,18 @@
 #include "Value.hpp"
 #include "scf.hpp"
 
-#include <forward_list>
 #include <amdgpu/RemoteMemory.hpp>
+#include <forward_list>
 #include <spirv/spirv-builder.hpp>
 #include <unordered_map>
 #include <util/unreachable.hpp>
 
 #include <bit>
-#include <span>
 #include <cassert>
 #include <cstdint>
-#include <vector>
 #include <map>
+#include <span>
+#include <vector>
 
 namespace amdgpu::shader {
 /*
@@ -99,13 +99,12 @@ class ConverterContext {
   spirv::Function mDiscardFn;
 
 public:
-  ConverterContext(RemoteMemory memory, Stage stage) : mMemory(memory), mStage(stage) {
+  ConverterContext(RemoteMemory memory, Stage stage)
+      : mMemory(memory), mStage(stage) {
     mGlslStd450 = mBuilder.createExtInstImport("GLSL.std.450");
   }
 
-  const decltype(mInterfaces) &getInterfaces() const {
-    return mInterfaces;
-  }
+  const decltype(mInterfaces) &getInterfaces() const { return mInterfaces; }
 
   spirv::SpirvBuilder &getBuilder() { return mBuilder; }
   RemoteMemory getMemory() const { return mMemory; }
@@ -155,11 +154,13 @@ public:
   }
 
   spirv::ArrayOfType<spirv::UIntType> getArrayUint32x8Type() {
-    return spirv::cast<spirv::ArrayOfType<spirv::UIntType>>(getType(TypeId::ArrayUInt32x8));
+    return spirv::cast<spirv::ArrayOfType<spirv::UIntType>>(
+        getType(TypeId::ArrayUInt32x8));
   }
 
   spirv::ArrayOfType<spirv::UIntType> getArrayUint32x16Type() {
-    return spirv::cast<spirv::ArrayOfType<spirv::UIntType>>(getType(TypeId::ArrayUInt32x16));
+    return spirv::cast<spirv::ArrayOfType<spirv::UIntType>>(
+        getType(TypeId::ArrayUInt32x16));
   }
 
   spirv::SIntType getSint32Type() {
@@ -225,12 +226,14 @@ public:
     return spirv::cast<spirv::ImageType>(getType(TypeId::Image2D));
   }
   spirv::SampledImageType getSampledImage2DType() {
-    return spirv::cast<spirv::SampledImageType>(getType(TypeId::SampledImage2D));
+    return spirv::cast<spirv::SampledImageType>(
+        getType(TypeId::SampledImage2D));
   }
 
   UniformInfo *createStorageBuffer(TypeId type);
   UniformInfo *getOrCreateStorageBuffer(std::uint32_t *vbuffer, TypeId type);
-  UniformInfo *getOrCreateUniformConstant(std::uint32_t *buffer, std::size_t size, TypeId type);
+  UniformInfo *getOrCreateUniformConstant(std::uint32_t *buffer,
+                                          std::size_t size, TypeId type);
   spirv::VariableValue getThreadId();
   spirv::VariableValue getWorkgroupId();
   spirv::VariableValue getLocalInvocationId();
@@ -250,8 +253,6 @@ public:
   Function *createFunction(std::size_t expectedSize);
   Fragment *createFragment(std::size_t expectedSize);
 
-  std::vector<UniformInfo> &getUniforms() {
-    return mUniforms;
-  }
+  std::vector<UniformInfo> &getUniforms() { return mUniforms; }
 };
 } // namespace amdgpu::shader
diff --git a/hw/amdgpu/shader/include/amdgpu/shader/Fragment.hpp b/hw/amdgpu/shader/include/amdgpu/shader/Fragment.hpp
index c3533af5d..03574657a 100644
--- a/hw/amdgpu/shader/include/amdgpu/shader/Fragment.hpp
+++ b/hw/amdgpu/shader/include/amdgpu/shader/Fragment.hpp
@@ -14,10 +14,7 @@
 #include <spirv/spirv-builder.hpp>
 
 namespace amdgpu::shader {
-enum class OperandGetFlags {
-  None,
-  PreserveType = 1 << 0
-};
+enum class OperandGetFlags { None, PreserveType = 1 << 0 };
 
 struct Function;
 class ConverterContext;
@@ -36,9 +33,7 @@ struct Fragment {
   std::uint64_t jumpAddress = 0;
   spirv::BoolValue branchCondition;
 
-  void appendBranch(Fragment &other) {
-    other.predecessors.push_back(this);
-  }
+  void appendBranch(Fragment &other) { other.predecessors.push_back(this); }
 
   void injectValuesFromPreds();
 
@@ -47,34 +42,31 @@ struct Fragment {
   spirv::SamplerValue createSampler(RegisterId base);
   spirv::ImageValue createImage(RegisterId base, bool r128); // TODO: params
   Value createCompositeExtract(Value composite, std::uint32_t member);
-  Value getOperand(RegisterId id, TypeId type, OperandGetFlags flags = OperandGetFlags::None);
+  Value getOperand(RegisterId id, TypeId type,
+                   OperandGetFlags flags = OperandGetFlags::None);
   void setOperand(RegisterId id, Value value);
   void setVcc(Value value);
   void setScc(Value value);
   spirv::BoolValue getScc();
-  spirv::Value createBitcast(spirv::Type to, spirv::Type from, spirv::Value value);
+  spirv::Value createBitcast(spirv::Type to, spirv::Type from,
+                             spirv::Value value);
 
-  Value getScalarOperand(int id, TypeId type, OperandGetFlags flags = OperandGetFlags::None) {
+  Value getScalarOperand(int id, TypeId type,
+                         OperandGetFlags flags = OperandGetFlags::None) {
     return getOperand(RegisterId::Scalar(id), type, flags);
   }
-  Value getVectorOperand(int id, TypeId type, OperandGetFlags flags = OperandGetFlags::None) {
+  Value getVectorOperand(int id, TypeId type,
+                         OperandGetFlags flags = OperandGetFlags::None) {
     return getOperand(RegisterId::Vector(id), type, flags);
   }
-  Value getAttrOperand(int id, TypeId type, OperandGetFlags flags = OperandGetFlags::None) {
+  Value getAttrOperand(int id, TypeId type,
+                       OperandGetFlags flags = OperandGetFlags::None) {
     return getOperand(RegisterId::Attr(id), type, flags);
   }
-  Value getVccLo() {
-    return getOperand(RegisterId::VccLo, TypeId::UInt32);
-  }
-  Value getVccHi() {
-    return getOperand(RegisterId::VccHi, TypeId::UInt32);
-  }
-  Value getExecLo() {
-    return getOperand(RegisterId::ExecLo, TypeId::UInt32);
-  }
-  Value getExecHi() {
-    return getOperand(RegisterId::ExecHi, TypeId::UInt32);
-  }
+  Value getVccLo() { return getOperand(RegisterId::VccLo, TypeId::UInt32); }
+  Value getVccHi() { return getOperand(RegisterId::VccHi, TypeId::UInt32); }
+  Value getExecLo() { return getOperand(RegisterId::ExecLo, TypeId::UInt32); }
+  Value getExecHi() { return getOperand(RegisterId::ExecHi, TypeId::UInt32); }
   void setScalarOperand(int id, Value value) {
     setOperand(RegisterId::Scalar(id), value);
   }
diff --git a/hw/amdgpu/shader/include/amdgpu/shader/Instruction.hpp b/hw/amdgpu/shader/include/amdgpu/shader/Instruction.hpp
index ced8d2b95..2d73e5544 100644
--- a/hw/amdgpu/shader/include/amdgpu/shader/Instruction.hpp
+++ b/hw/amdgpu/shader/include/amdgpu/shader/Instruction.hpp
@@ -1419,7 +1419,8 @@ struct Mtbuf {
   bool idxen = fetchMaskedValue(inst[0], idxenMask);
   bool glc = fetchMaskedValue(inst[0], glcMask);
   SurfaceFormat dfmt = (SurfaceFormat)fetchMaskedValue(inst[0], dfmtMask);
-  TextureChannelType nfmt = (TextureChannelType)fetchMaskedValue(inst[0], nfmtMask);
+  TextureChannelType nfmt =
+      (TextureChannelType)fetchMaskedValue(inst[0], nfmtMask);
 
   std::uint8_t vaddr = fetchMaskedValue(inst[1], vaddrMask);
   std::uint8_t vdata = fetchMaskedValue(inst[1], vdataMask);
diff --git a/hw/amdgpu/shader/include/amdgpu/shader/cf.hpp b/hw/amdgpu/shader/include/amdgpu/shader/cf.hpp
index 8fcedc8c3..e3936225d 100644
--- a/hw/amdgpu/shader/include/amdgpu/shader/cf.hpp
+++ b/hw/amdgpu/shader/include/amdgpu/shader/cf.hpp
@@ -73,7 +73,8 @@ public:
     }
   }
 
-  template <std::invocable<BasicBlock *> T> void walkPredecessors(T &&cb) const {
+  template <std::invocable<BasicBlock *> T>
+  void walkPredecessors(T &&cb) const {
     for (auto pred : predecessors) {
       cb(pred);
     }
@@ -92,7 +93,9 @@ public:
     return successors[1] != nullptr ? 2 : 1;
   }
 
-  BasicBlock *getSuccessor(std::size_t index) const { return successors[index]; }
+  BasicBlock *getSuccessor(std::size_t index) const {
+    return successors[index];
+  }
 
   void split(BasicBlock *target);
 };
@@ -108,7 +111,7 @@ public:
 
     return nullptr;
   }
-  
+
   BasicBlock *getBasicBlock(std::uint64_t address) {
     if (auto it = basicBlocks.lower_bound(address); it != basicBlocks.end()) {
       auto bb = &it->second;
diff --git a/hw/amdgpu/shader/include/amdgpu/shader/scf.hpp b/hw/amdgpu/shader/include/amdgpu/shader/scf.hpp
index d439ee048..9ad804115 100644
--- a/hw/amdgpu/shader/include/amdgpu/shader/scf.hpp
+++ b/hw/amdgpu/shader/include/amdgpu/shader/scf.hpp
@@ -31,51 +31,40 @@ class Node {
 public:
   virtual ~Node() = default;
   virtual void print(const PrintOptions &options, unsigned depth) = 0;
-  virtual bool isEqual(const Node &other) const {
-    return this == &other;
-  }
+  virtual bool isEqual(const Node &other) const { return this == &other; }
 
-  void dump() {
-    print({}, 0);
-  }
+  void dump() { print({}, 0); }
 
-  void setParent(Node *parent) {
-    mParent = parent;
-  }
+  void setParent(Node *parent) { mParent = parent; }
 
-  Node *getParent() const {
-    return mParent;
-  }
+  Node *getParent() const { return mParent; }
 
-  template<typename T> requires(std::is_base_of_v<Node, T>)
-  auto getParent() const -> decltype(dynCast<T>(mParent)) {
+  template <typename T>
+  requires(std::is_base_of_v<Node, T>) auto getParent() const
+      -> decltype(dynCast<T>(mParent)) {
     return dynCast<T>(mParent);
   }
 
-  Node *getNext() const {
-    return mNext;
-  }
+  Node *getNext() const { return mNext; }
 
-  Node *getPrev() const {
-    return mPrev; 
-  }
+  Node *getPrev() const { return mPrev; }
 
   friend class Block;
 };
 
 template <typename T, typename ST>
-  requires(std::is_base_of_v<Node, T> && std::is_base_of_v<Node, ST>) &&
-          requires(ST *s) { dynamic_cast<T *>(s); }
-T *dynCast(ST *s) {
-  return dynamic_cast<T *>(s);
+requires(std::is_base_of_v<Node, T> &&std::is_base_of_v<Node, ST>) &&
+    requires(ST *s) {
+  dynamic_cast<T *>(s);
 }
+T *dynCast(ST *s) { return dynamic_cast<T *>(s); }
 
 template <typename T, typename ST>
-  requires(std::is_base_of_v<Node, T> && std::is_base_of_v<Node, ST>) &&
-          requires(const ST *s) { dynamic_cast<const T *>(s); }
-const T *dynCast(const ST *s) {
-  return dynamic_cast<const T *>(s);
+requires(std::is_base_of_v<Node, T> &&std::is_base_of_v<Node, ST>) &&
+    requires(const ST *s) {
+  dynamic_cast<const T *>(s);
 }
+const T *dynCast(const ST *s) { return dynamic_cast<const T *>(s); }
 
 inline bool isNodeEqual(const Node *lhs, const Node *rhs) {
   if (lhs == rhs) {
@@ -105,7 +94,6 @@ struct Return final : Node {
   }
 };
 
-
 class Context;
 
 class Block final : public Node {
@@ -124,25 +112,14 @@ public:
     std::printf("%s}\n", options.makeIdent(depth).c_str());
   }
 
-  bool isEmpty() const {
-    return mBegin == nullptr;
-  }
+  bool isEmpty() const { return mBegin == nullptr; }
 
-  Node *getRootNode() const {
-    return mBegin;
-  }
-  Node *getLastNode() const {
-    return mEnd;
-  }
+  Node *getRootNode() const { return mBegin; }
+  Node *getLastNode() const { return mEnd; }
 
-  void setUserData(void *data) {
-    mUserData = data;
-  }
-  void* getUserData() const {
-    return mUserData;
-  }
-  template<typename T>
-  T* getUserData() const {
+  void setUserData(void *data) { mUserData = data; }
+  void *getUserData() const { return mUserData; }
+  template <typename T> T *getUserData() const {
     return static_cast<T *>(mUserData);
   }
 
@@ -239,9 +216,7 @@ public:
     }
   }
 
-  Block *getBlock() const {
-    return dynCast<Block>(getParent());
-  }
+  Block *getBlock() const { return dynCast<Block>(getParent()); }
 
   bool isEqual(const Node &other) const override {
     if (this == &other) {
@@ -320,9 +295,7 @@ struct Jump final : Node {
 struct Loop final : Node {
   Block *body;
 
-  Loop(Block *body) : body(body) {
-    body->setParent(this);
-  }
+  Loop(Block *body) : body(body) { body->setParent(this); }
 
   bool isEqual(const Node &other) const override {
     if (this == &other) {
@@ -358,8 +331,7 @@ class Context {
 
 public:
   template <typename T, typename... ArgsT>
-    requires(std::is_constructible_v<T, ArgsT...>)
-  T *create(ArgsT &&...args) {
+  requires(std::is_constructible_v<T, ArgsT...>) T *create(ArgsT &&...args) {
     auto result = new T(std::forward<ArgsT>(args)...);
     mNodes.push_front(std::unique_ptr<Node>{result});
     return result;
diff --git a/hw/amdgpu/shader/src/CfBuilder.cpp b/hw/amdgpu/shader/src/CfBuilder.cpp
index 51f435929..06cdcad17 100644
--- a/hw/amdgpu/shader/src/CfBuilder.cpp
+++ b/hw/amdgpu/shader/src/CfBuilder.cpp
@@ -1,7 +1,7 @@
 #include "CfBuilder.hpp"
 #include "Instruction.hpp"
-#include <cassert>
 #include <amdgpu/RemoteMemory.hpp>
+#include <cassert>
 #include <unordered_set>
 
 using namespace amdgpu;
@@ -176,9 +176,8 @@ struct CfgBuilder {
   }
 };
 
-cf::BasicBlock *amdgpu::shader::buildCf(cf::Context &ctxt,
-                                           RemoteMemory memory,
-                                           std::uint64_t entryPoint) {
+cf::BasicBlock *amdgpu::shader::buildCf(cf::Context &ctxt, RemoteMemory memory,
+                                        std::uint64_t entryPoint) {
   CfgBuilder builder;
   builder.context = &ctxt;
   builder.memory = memory;
diff --git a/hw/amdgpu/shader/src/Converter.cpp b/hw/amdgpu/shader/src/Converter.cpp
index c329a8683..ebfb8fd97 100644
--- a/hw/amdgpu/shader/src/Converter.cpp
+++ b/hw/amdgpu/shader/src/Converter.cpp
@@ -6,8 +6,8 @@
 #include "Instruction.hpp"
 #include "RegisterId.hpp"
 #include "RegisterState.hpp"
-#include "cf.hpp"
 #include "amdgpu/RemoteMemory.hpp"
+#include "cf.hpp"
 #include "scf.hpp"
 #include "util/unreachable.hpp"
 #include <compare>
@@ -108,8 +108,9 @@ private:
            instClass == InstructionClass::Vintrp ||
            instClass == InstructionClass::Exp ||
            instClass == InstructionClass::Vop1 ||
-           instClass == InstructionClass::Vopc/* ||
-           instClass == InstructionClass::Smrd*/;
+           instClass == InstructionClass::Vopc /* ||
+            instClass == InstructionClass::Smrd*/
+        ;
   }
 
   spirv::BoolValue createExecTest(Fragment *fragment) {
@@ -274,10 +275,11 @@ private:
 };
 }; // namespace amdgpu::shader
 
-amdgpu::shader::Shader amdgpu::shader::convert(
-    RemoteMemory memory, Stage stage, std::uint64_t entry,
-    std::span<const std::uint32_t> userSpgrs, int bindingOffset,
-    std::uint32_t dimX, std::uint32_t dimY, std::uint32_t dimZ) {
+amdgpu::shader::Shader
+amdgpu::shader::convert(RemoteMemory memory, Stage stage, std::uint64_t entry,
+                        std::span<const std::uint32_t> userSpgrs,
+                        int bindingOffset, std::uint32_t dimX,
+                        std::uint32_t dimY, std::uint32_t dimZ) {
   ConverterContext ctxt(memory, stage);
   auto &builder = ctxt.getBuilder();
   builder.createCapability(spv::Capability::Shader);
diff --git a/hw/amdgpu/shader/src/ConverterContext.cpp b/hw/amdgpu/shader/src/ConverterContext.cpp
index ceb2c3cb0..7c4cf3c12 100644
--- a/hw/amdgpu/shader/src/ConverterContext.cpp
+++ b/hw/amdgpu/shader/src/ConverterContext.cpp
@@ -217,7 +217,7 @@ UniformInfo *ConverterContext::createStorageBuffer(TypeId type) {
   newUniform.variable = uniformVariable;
   newUniform.isBuffer = true;
   std::printf("new storage buffer %u of type %u\n", newUniform.index,
-               newUniform.typeId.raw);
+              newUniform.typeId.raw);
   return &newUniform;
 }
 
@@ -397,11 +397,11 @@ spirv::VariableValue ConverterContext::getFragCoord() {
   }
 
   auto inputType = getPointerType(spv::StorageClass::Input, TypeId::Float32x4);
-  mFragCoord =
-      mBuilder.createVariable(inputType, spv::StorageClass::Input);
+  mFragCoord = mBuilder.createVariable(inputType, spv::StorageClass::Input);
 
-  mBuilder.createDecorate(mFragCoord, spv::Decoration::BuiltIn,
-                          {{static_cast<std::uint32_t>(spv::BuiltIn::FragCoord)}});
+  mBuilder.createDecorate(
+      mFragCoord, spv::Decoration::BuiltIn,
+      {{static_cast<std::uint32_t>(spv::BuiltIn::FragCoord)}});
 
   mInterfaces.push_back(mFragCoord);
   return mFragCoord;
diff --git a/hw/amdgpu/shader/src/Fragment.cpp b/hw/amdgpu/shader/src/Fragment.cpp
index 23a650c67..cbd5ff8cc 100644
--- a/hw/amdgpu/shader/src/Fragment.cpp
+++ b/hw/amdgpu/shader/src/Fragment.cpp
@@ -3288,7 +3288,8 @@ void convertMimg(Fragment &fragment, Mimg inst) {
   fragment.registers->pc += Mimg::kMinInstSize * sizeof(std::uint32_t);
   switch (inst.op) {
   case Mimg::Op::IMAGE_GET_RESINFO: {
-    auto image = fragment.createImage(RegisterId::Raw(inst.srsrc << 2), inst.r128);
+    auto image =
+        fragment.createImage(RegisterId::Raw(inst.srsrc << 2), inst.r128);
     spirv::Value values[4];
     auto uint32T = fragment.context->getUInt32Type();
 
@@ -3314,13 +3315,15 @@ void convertMimg(Fragment &fragment, Mimg inst) {
 
     for (std::size_t dstOffset = 0, i = 0; i < 4; ++i) {
       if (inst.dmask & (1 << i)) {
-        fragment.setVectorOperand(inst.vdata + dstOffset++, {uint32T, values[i]});
+        fragment.setVectorOperand(inst.vdata + dstOffset++,
+                                  {uint32T, values[i]});
       }
     }
     break;
   }
   case Mimg::Op::IMAGE_SAMPLE: {
-    auto image = fragment.createImage(RegisterId::Raw(inst.srsrc << 2), inst.r128);
+    auto image =
+        fragment.createImage(RegisterId::Raw(inst.srsrc << 2), inst.r128);
     auto sampler = fragment.createSampler(RegisterId::Raw(inst.ssamp << 2));
     auto coord0 = fragment.getVectorOperand(inst.vaddr, TypeId::Float32).value;
     auto coord1 =
@@ -3342,8 +3345,9 @@ void convertMimg(Fragment &fragment, Mimg inst) {
     for (std::uint32_t dstOffset = 0, i = 0; i < 4; ++i) {
       if (inst.dmask & (1 << i)) {
         fragment.setVectorOperand(
-            inst.vdata + dstOffset++, {floatT, fragment.builder.createCompositeExtract(
-                                         floatT, value, {{i}})});
+            inst.vdata + dstOffset++,
+            {floatT,
+             fragment.builder.createCompositeExtract(floatT, value, {{i}})});
       }
     }
     break;
@@ -3353,8 +3357,8 @@ void convertMimg(Fragment &fragment, Mimg inst) {
     auto intT = fragment.context->getUInt32Type();
     for (std::uint32_t dstOffset = 0, i = 0; i < 4; ++i) {
       if (inst.dmask & (1 << i)) {
-        fragment.setVectorOperand(
-            inst.vdata + dstOffset++, {intT, fragment.context->getUInt32(0)});
+        fragment.setVectorOperand(inst.vdata + dstOffset++,
+                                  {intT, fragment.context->getUInt32(0)});
       }
     }
     break;
@@ -3457,19 +3461,19 @@ void convertExp(Fragment &fragment, Exp inst) {
 
   auto resultType = fragment.context->getFloat32x4Type();
   auto floatType = fragment.context->getFloat32Type();
-/*
-  if (inst.en != 0xf) {
-    auto prevValue = fragment.getExportTarget(inst.target, TypeId::Float32x4);
-    if (prevValue) {
-      for (std::uint32_t i = 0; i < 4; ++i) {
-        if (~inst.en & (1 << i)) {
-          exports[i] = fragment.builder.createCompositeExtract(
-              floatType, prevValue.value, {{i}});
+  /*
+    if (inst.en != 0xf) {
+      auto prevValue = fragment.getExportTarget(inst.target, TypeId::Float32x4);
+      if (prevValue) {
+        for (std::uint32_t i = 0; i < 4; ++i) {
+          if (~inst.en & (1 << i)) {
+            exports[i] = fragment.builder.createCompositeExtract(
+                floatType, prevValue.value, {{i}});
+          }
         }
       }
     }
-  }
-*/
+  */
 
   auto value = fragment.builder.createCompositeConstruct(resultType, exports);
   fragment.setExportTarget(inst.target, {resultType, value});
@@ -3535,7 +3539,6 @@ void convertVop1(Fragment &fragment, Vop1 inst) {
     break;
   }
 
-
   case Vop1::Op::V_FRACT_F32: {
     auto src = spirv::cast<spirv::FloatValue>(
         fragment.getScalarOperand(inst.src0, TypeId::Float32).value);
@@ -5412,8 +5415,7 @@ Value amdgpu::shader::Fragment::getRegister(RegisterId id) {
   return result;
 }
 
-Value amdgpu::shader::Fragment::getRegister(RegisterId id,
-                                               spirv::Type type) {
+Value amdgpu::shader::Fragment::getRegister(RegisterId id, spirv::Type type) {
   auto result = getRegister(id);
 
   if (!result) {
diff --git a/hw/amdgpu/shader/src/Function.cpp b/hw/amdgpu/shader/src/Function.cpp
index 75d359320..a87618240 100644
--- a/hw/amdgpu/shader/src/Function.cpp
+++ b/hw/amdgpu/shader/src/Function.cpp
@@ -268,7 +268,8 @@ void Function::insertReturn() {
     exitFragment.builder.createStore(valuePointer, value.value);
   }
 
-  auto resultValue = exitFragment.builder.createLoad(resultType, resultVariable);
+  auto resultValue =
+      exitFragment.builder.createLoad(resultType, resultVariable);
 
   exitFragment.builder.createReturnValue(resultValue);
 }
diff --git a/hw/amdgpu/shader/src/Instruction.cpp b/hw/amdgpu/shader/src/Instruction.cpp
index e4a2b01c1..f85f06180 100644
--- a/hw/amdgpu/shader/src/Instruction.cpp
+++ b/hw/amdgpu/shader/src/Instruction.cpp
@@ -3013,8 +3013,8 @@ void amdgpu::shader::Mtbuf::dump() const {
   printScalarOperand(soffset, inst + instSize);
   printf(" #offset=%x,offen=%x,idxen=%x,glc=%x,op=%x,dfmt=%x,nfmt=%x,vaddr=%x,"
          "vdata=%x,srsrc=%x,slc=%x,tfe=%x,soffset=%x",
-         offset, offen, idxen, glc, (unsigned)op, dfmt, nfmt, vaddr, vdata, srsrc, slc,
-         tfe, soffset);
+         offset, offen, idxen, glc, (unsigned)op, dfmt, nfmt, vaddr, vdata,
+         srsrc, slc, tfe, soffset);
 }
 void amdgpu::shader::Mimg::dump() const {
   int instSize = kMinInstSize;
diff --git a/hw/amdgpu/shader/src/RegisterState.cpp b/hw/amdgpu/shader/src/RegisterState.cpp
index b2dc221af..9ad39f1ee 100644
--- a/hw/amdgpu/shader/src/RegisterState.cpp
+++ b/hw/amdgpu/shader/src/RegisterState.cpp
@@ -39,20 +39,35 @@ amdgpu::shader::RegisterState::getRegister(RegisterId regId) {
   util::unreachable();
 }
 
-void amdgpu::shader::RegisterState::setRegister(RegisterId regId,
-                                                   Value value) {
+void amdgpu::shader::RegisterState::setRegister(RegisterId regId, Value value) {
   auto offset = regId.getOffset();
 
   if (regId.isScalar()) {
     switch (offset) {
-    case 0 ... 103: sgprs[offset] = value; return;
-    case 106: vccLo = value; return;
-    case 107: vccHi = value; return;
-    case 124: m0 = value; return;
-    case 126: execLo = value; return;
-    case 127: execHi = value; return;
-    case 253: scc = value; return;
-    case 254: ldsDirect = value; return;
+    case 0 ... 103:
+      sgprs[offset] = value;
+      return;
+    case 106:
+      vccLo = value;
+      return;
+    case 107:
+      vccHi = value;
+      return;
+    case 124:
+      m0 = value;
+      return;
+    case 126:
+      execLo = value;
+      return;
+    case 127:
+      execHi = value;
+      return;
+    case 253:
+      scc = value;
+      return;
+    case 254:
+      ldsDirect = value;
+      return;
     }
 
     util::unreachable();
diff --git a/hw/amdgpu/shader/src/TypeId.cpp b/hw/amdgpu/shader/src/TypeId.cpp
index 4e1ea954d..48a56e22e 100644
--- a/hw/amdgpu/shader/src/TypeId.cpp
+++ b/hw/amdgpu/shader/src/TypeId.cpp
@@ -99,7 +99,7 @@ std::size_t amdgpu::shader::TypeId::getElementsCount() const {
   case TypeId::Float32:
   case TypeId::Float64:
     return 1;
-  
+
   case TypeId::UInt32x2:
     return 2;
   case TypeId::UInt32x3:
diff --git a/hw/amdgpu/shader/src/scf.cpp b/hw/amdgpu/shader/src/scf.cpp
index b11fd92c3..8c5de5c0a 100644
--- a/hw/amdgpu/shader/src/scf.cpp
+++ b/hw/amdgpu/shader/src/scf.cpp
@@ -7,7 +7,7 @@
 
 void scf::Block::eraseFrom(Node *endBefore) {
   mEnd = endBefore->getPrev();
-  if (mEnd != nullptr) { 
+  if (mEnd != nullptr) {
     mEnd->mNext = nullptr;
   } else {
     mBegin = nullptr;
diff --git a/orbis-kernel/examples/standalone/orbis-kernel-config/orbis-config.hpp b/orbis-kernel/examples/standalone/orbis-kernel-config/orbis-config.hpp
index 76fd40019..056c68035 100644
--- a/orbis-kernel/examples/standalone/orbis-kernel-config/orbis-config.hpp
+++ b/orbis-kernel/examples/standalone/orbis-kernel-config/orbis-config.hpp
@@ -27,23 +27,24 @@ using slong = int64_t;
 using ulong = uint64_t;
 
 template <typename T> using ptr = T *;
-template <typename T> using cptr = T * const;
+template <typename T> using cptr = T *const;
 
 using caddr_t = ptr<char>;
 
 inline ErrorCode uread(void *kernelAddress, ptr<const void> userAddress,
-                  size_t size) {
+                       size_t size) {
   std::memcpy(kernelAddress, userAddress, size);
   return {};
 }
 
 inline ErrorCode uwrite(ptr<void> userAddress, const void *kernelAddress,
-                   size_t size) {
+                        size_t size) {
   std::memcpy(userAddress, kernelAddress, size);
   return {};
 }
 
-inline ErrorCode ureadString(char *kernelAddress, size_t kernelSize, ptr<const char> userAddress) {
+inline ErrorCode ureadString(char *kernelAddress, size_t kernelSize,
+                             ptr<const char> userAddress) {
   std::strncpy(kernelAddress, userAddress, kernelSize);
   if (kernelAddress[kernelSize - 1] != '\0') {
     kernelAddress[kernelSize - 1] = '\0';
diff --git a/orbis-kernel/examples/standalone/src/main.cpp b/orbis-kernel/examples/standalone/src/main.cpp
index a6d499971..f92f6ccc7 100644
--- a/orbis-kernel/examples/standalone/src/main.cpp
+++ b/orbis-kernel/examples/standalone/src/main.cpp
@@ -38,49 +38,100 @@ namespace orbis {
 uint64_t readRegister(void *context, RegisterId id) {
   auto c = reinterpret_cast<Registers *>(context);
   switch (id) {
-  case RegisterId::r15: return c->r15;
-  case RegisterId::r14: return c->r14;
-  case RegisterId::r13: return c->r13;
-  case RegisterId::r12: return c->r12;
-  case RegisterId::r11: return c->r11;
-  case RegisterId::r10: return c->r10;
-  case RegisterId::r9: return c->r9;
-  case RegisterId::r8: return c->r8;
-  case RegisterId::rdi: return c->rdi;
-  case RegisterId::rsi: return c->rsi;
-  case RegisterId::rbp: return c->rbp;
-  case RegisterId::rbx: return c->rbx;
-  case RegisterId::rdx: return c->rdx;
-  case RegisterId::rcx: return c->rcx;
-  case RegisterId::rax: return c->rax;
-  case RegisterId::rsp: return c->rsp;
-  case RegisterId::rflags: return c->rflags;
+  case RegisterId::r15:
+    return c->r15;
+  case RegisterId::r14:
+    return c->r14;
+  case RegisterId::r13:
+    return c->r13;
+  case RegisterId::r12:
+    return c->r12;
+  case RegisterId::r11:
+    return c->r11;
+  case RegisterId::r10:
+    return c->r10;
+  case RegisterId::r9:
+    return c->r9;
+  case RegisterId::r8:
+    return c->r8;
+  case RegisterId::rdi:
+    return c->rdi;
+  case RegisterId::rsi:
+    return c->rsi;
+  case RegisterId::rbp:
+    return c->rbp;
+  case RegisterId::rbx:
+    return c->rbx;
+  case RegisterId::rdx:
+    return c->rdx;
+  case RegisterId::rcx:
+    return c->rcx;
+  case RegisterId::rax:
+    return c->rax;
+  case RegisterId::rsp:
+    return c->rsp;
+  case RegisterId::rflags:
+    return c->rflags;
   }
 }
 
 void writeRegister(void *context, RegisterId id, uint64_t value) {
   auto c = reinterpret_cast<Registers *>(context);
   switch (id) {
-  case RegisterId::r15: c->r15 = value; return;
-  case RegisterId::r14: c->r14 = value; return;
-  case RegisterId::r13: c->r13 = value; return;
-  case RegisterId::r12: c->r12 = value; return;
-  case RegisterId::r11: c->r11 = value; return;
-  case RegisterId::r10: c->r10 = value; return;
-  case RegisterId::r9: c->r9 = value; return;
-  case RegisterId::r8: c->r8 = value; return;
-  case RegisterId::rdi: c->rdi = value; return;
-  case RegisterId::rsi: c->rsi = value; return;
-  case RegisterId::rbp: c->rbp = value; return;
-  case RegisterId::rbx: c->rbx = value; return;
-  case RegisterId::rdx: c->rdx = value; return;
-  case RegisterId::rcx: c->rcx = value; return;
-  case RegisterId::rax: c->rax = value; return;
-  case RegisterId::rsp: c->rsp = value; return;
-  case RegisterId::rflags: c->rflags = value; return;
+  case RegisterId::r15:
+    c->r15 = value;
+    return;
+  case RegisterId::r14:
+    c->r14 = value;
+    return;
+  case RegisterId::r13:
+    c->r13 = value;
+    return;
+  case RegisterId::r12:
+    c->r12 = value;
+    return;
+  case RegisterId::r11:
+    c->r11 = value;
+    return;
+  case RegisterId::r10:
+    c->r10 = value;
+    return;
+  case RegisterId::r9:
+    c->r9 = value;
+    return;
+  case RegisterId::r8:
+    c->r8 = value;
+    return;
+  case RegisterId::rdi:
+    c->rdi = value;
+    return;
+  case RegisterId::rsi:
+    c->rsi = value;
+    return;
+  case RegisterId::rbp:
+    c->rbp = value;
+    return;
+  case RegisterId::rbx:
+    c->rbx = value;
+    return;
+  case RegisterId::rdx:
+    c->rdx = value;
+    return;
+  case RegisterId::rcx:
+    c->rcx = value;
+    return;
+  case RegisterId::rax:
+    c->rax = value;
+    return;
+  case RegisterId::rsp:
+    c->rsp = value;
+    return;
+  case RegisterId::rflags:
+    c->rflags = value;
+    return;
   }
 }
-}
+} // namespace orbis
 
 static thread_local orbis::Thread *g_guestThread = nullptr;
 
@@ -100,9 +151,7 @@ class CPU {
 public:
   CPU(int index) : m_index(index) {}
 
-  int getIndex() const {
-    return m_index;
-  }
+  int getIndex() const { return m_index; }
 
   void addTask(orbis::Thread *thread, std::function<void()> task) {
     m_workQueue.push_back({thread, std::move(task)});
@@ -160,14 +209,13 @@ public:
 };
 
 struct orbis::ProcessOps procOps = {
-  .exit = [](orbis::Thread *, orbis::sint status) -> orbis::SysResult {
-    std::printf("sys_exit(%u)\n", status);
-    std::exit(status);
-  }
-};
+    .exit = [](orbis::Thread *, orbis::sint status) -> orbis::SysResult {
+      std::printf("sys_exit(%u)\n", status);
+      std::exit(status);
+    }};
 
 static orbis::Thread *allocateGuestThread(orbis::Process *process,
-                                   orbis::lwpid_t tid) {
+                                          orbis::lwpid_t tid) {
   auto guestThread = new orbis::Thread{};
   guestThread->state = orbis::ThreadState::RUNQ;
   guestThread->tid = tid;
@@ -175,7 +223,6 @@ static orbis::Thread *allocateGuestThread(orbis::Process *process,
   return guestThread;
 }
 
-
 static void onSysEnter(orbis::Thread *thread, int id, uint64_t *args,
                        int argsCount) {
   std::printf("   [%u] sys_%u(", thread->tid, id);
diff --git a/orbis-kernel/include/orbis/KernelAllocator.hpp b/orbis-kernel/include/orbis/KernelAllocator.hpp
index 879d55312..b82352637 100644
--- a/orbis-kernel/include/orbis/KernelAllocator.hpp
+++ b/orbis-kernel/include/orbis/KernelAllocator.hpp
@@ -1,17 +1,17 @@
 #pragma once
 
 #include "utils/Rc.hpp"
-#include <utility>
-#include <string>
-#include <vector>
 #include <deque>
 #include <map>
+#include <string>
 #include <unordered_map>
+#include <utility>
+#include <vector>
 
 namespace orbis {
 inline namespace utils {
 void *kalloc(std::size_t size, std::size_t align);
-void kfree(void* ptr, std::size_t size);
+void kfree(void *ptr, std::size_t size);
 template <typename T> struct kallocator {
   using value_type = T;
 
@@ -21,9 +21,7 @@ template <typename T> struct kallocator {
     return static_cast<T *>(kalloc(sizeof(T) * n, alignof(T)));
   }
 
-  void deallocate(T *p, std::size_t n) {
-    kfree(p, sizeof(T) * n);
-  }
+  void deallocate(T *p, std::size_t n) { kfree(p, sizeof(T) * n); }
 
   template <typename U>
   friend constexpr bool operator==(const kallocator &,
@@ -32,7 +30,8 @@ template <typename T> struct kallocator {
   }
 };
 
-using kstring = std::basic_string<char, std::char_traits<char>, kallocator<char>>;
+using kstring =
+    std::basic_string<char, std::char_traits<char>, kallocator<char>>;
 template <typename T> using kvector = std::vector<T, kallocator<T>>;
 template <typename T> using kdeque = std::deque<T, kallocator<T>>;
 template <typename K, typename T, typename Cmp = std::less<>>
@@ -48,7 +47,7 @@ using kunmap =
 template <typename T, typename... Args> T *knew(Args &&...args) {
   auto loc = static_cast<T *>(utils::kalloc(sizeof(T), alignof(T)));
   auto res = std::construct_at(loc, std::forward<Args>(args)...);
-  if constexpr (requires(T *t) { t->_total_size = sizeof(T); })
+  if constexpr (requires(T * t) { t->_total_size = sizeof(T); })
     res->_total_size = sizeof(T);
   return res;
 }
diff --git a/orbis-kernel/include/orbis/error.hpp b/orbis-kernel/include/orbis/error.hpp
index cf2be1435..c670a46df 100644
--- a/orbis-kernel/include/orbis/error.hpp
+++ b/orbis-kernel/include/orbis/error.hpp
@@ -1,4 +1,4 @@
 #pragma once
 
-#include "error/SysResult.hpp" // IWYU pragma: export
 #include "error/ErrorCode.hpp" // IWYU pragma: export
+#include "error/SysResult.hpp" // IWYU pragma: export
diff --git a/orbis-kernel/include/orbis/error/SysResult.hpp b/orbis-kernel/include/orbis/error/SysResult.hpp
index d112894a9..99308d6ac 100644
--- a/orbis-kernel/include/orbis/error/SysResult.hpp
+++ b/orbis-kernel/include/orbis/error/SysResult.hpp
@@ -8,7 +8,7 @@ class SysResult {
 
 public:
   SysResult() = default;
-  SysResult(ErrorCode ec) : mValue(-static_cast<int>(ec)){}
+  SysResult(ErrorCode ec) : mValue(-static_cast<int>(ec)) {}
 
   [[nodiscard]] static SysResult notAnError(ErrorCode ec) {
     SysResult result;
diff --git a/orbis-kernel/include/orbis/evf.hpp b/orbis-kernel/include/orbis/evf.hpp
index 90787807f..8b38b964e 100644
--- a/orbis-kernel/include/orbis/evf.hpp
+++ b/orbis-kernel/include/orbis/evf.hpp
@@ -62,11 +62,7 @@ struct EventFlag {
 
   shared_mutex queueMtx;
 
-  enum class NotifyType {
-    Set,
-    Cancel,
-    Destroy
-  };
+  enum class NotifyType { Set, Cancel, Destroy };
 
   explicit EventFlag(std::int32_t attrs) : attrs(attrs) {}
 
@@ -77,17 +73,13 @@ struct EventFlag {
                     std::uint64_t bitPattern, std::uint64_t *patternSet);
   std::size_t notify(NotifyType type, std::uint64_t bits);
 
-  std::size_t destroy() {
-    return notify(NotifyType::Destroy, {});
-  }
+  std::size_t destroy() { return notify(NotifyType::Destroy, {}); }
 
   std::size_t cancel(std::uint64_t value) {
     return notify(NotifyType::Cancel, value);
   }
 
-  std::size_t set(std::uint64_t bits) {
-    return notify(NotifyType::Set, bits);
-  }
+  std::size_t set(std::uint64_t bits) { return notify(NotifyType::Set, bits); }
 
   void clear(std::uint64_t bits) {
     writer_lock lock(queueMtx);
diff --git a/orbis-kernel/include/orbis/module.hpp b/orbis-kernel/include/orbis/module.hpp
index 3cf1be79f..43507ddc1 100644
--- a/orbis-kernel/include/orbis/module.hpp
+++ b/orbis-kernel/include/orbis/module.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
-#include "module/Module.hpp" // IWYU pragma: export
-#include "module/ModuleHandle.hpp" // IWYU pragma: export
-#include "module/ModuleInfo.hpp" // IWYU pragma: export
-#include "module/ModuleInfoEx.hpp" // IWYU pragma: export
+#include "module/Module.hpp"        // IWYU pragma: export
+#include "module/ModuleHandle.hpp"  // IWYU pragma: export
+#include "module/ModuleInfo.hpp"    // IWYU pragma: export
+#include "module/ModuleInfoEx.hpp"  // IWYU pragma: export
 #include "module/ModuleSegment.hpp" // IWYU pragma: export
diff --git a/orbis-kernel/include/orbis/module/Module.hpp b/orbis-kernel/include/orbis/module/Module.hpp
index aa4bd4953..6d4aa601c 100644
--- a/orbis-kernel/include/orbis/module/Module.hpp
+++ b/orbis-kernel/include/orbis/module/Module.hpp
@@ -3,13 +3,13 @@
 #include "ModuleHandle.hpp"
 #include "ModuleSegment.hpp"
 
-#include "../utils/Rc.hpp"
 #include "../KernelAllocator.hpp"
+#include "../utils/Rc.hpp"
 
 #include "orbis-config.hpp"
 #include <cstddef>
-#include <vector>
 #include <string>
+#include <vector>
 
 namespace orbis {
 struct Thread;
@@ -22,12 +22,7 @@ struct ModuleNeeded {
   bool isExport;
 };
 
-enum class SymbolBind : std::uint8_t {
-  Local,
-  Global,
-  Weak,
-  Unique = 10
-};
+enum class SymbolBind : std::uint8_t { Local, Global, Weak, Unique = 10 };
 
 enum class SymbolVisibility : std::uint8_t {
   Default,
@@ -47,7 +42,6 @@ enum class SymbolType : std::uint8_t {
   IFunc = 10,
 };
 
-
 struct Symbol {
   std::int32_t moduleIndex;
   std::uint32_t libraryIndex;
@@ -130,7 +124,8 @@ struct Module final {
   }
 
   void decRef() {
-    if (references.fetch_sub(1, std::memory_order::relaxed) == 1 && proc != nullptr) {
+    if (references.fetch_sub(1, std::memory_order::relaxed) == 1 &&
+        proc != nullptr) {
       destroy();
     }
   }
@@ -141,5 +136,6 @@ private:
   void destroy();
 };
 
-utils::Ref<Module> createModule(Thread *p, std::string vfsPath, const char *name);
+utils::Ref<Module> createModule(Thread *p, std::string vfsPath,
+                                const char *name);
 } // namespace orbis
diff --git a/orbis-kernel/include/orbis/sys/sysproto.hpp b/orbis-kernel/include/orbis/sys/sysproto.hpp
index 47cf15727..aea81f32c 100644
--- a/orbis-kernel/include/orbis/sys/sysproto.hpp
+++ b/orbis-kernel/include/orbis/sys/sysproto.hpp
@@ -1,6 +1,6 @@
+#include <array>
 #include <orbis/error.hpp>
 #include <orbis/thread.hpp>
-#include <array>
 
 namespace orbis {
 using acl_type_t = sint;
@@ -24,7 +24,8 @@ SysResult sys_read(Thread *thread, sint fd, ptr<void> buf, size_t nbyte);
 SysResult sys_write(Thread *thread, sint fd, ptr<const void> buf, size_t nbyte);
 SysResult sys_open(Thread *thread, ptr<char> path, sint flags, sint mode);
 SysResult sys_close(Thread *thread, sint fd);
-SysResult sys_wait4(Thread *thread, sint pid, ptr<sint> status, sint options, ptr<struct rusage> rusage);
+SysResult sys_wait4(Thread *thread, sint pid, ptr<sint> status, sint options,
+                    ptr<struct rusage> rusage);
 SysResult sys_link(Thread *thread, ptr<char> path, ptr<char> link);
 SysResult sys_unlink(Thread *thread, ptr<char> path);
 SysResult sys_chdir(Thread *thread, ptr<char> path);
@@ -34,18 +35,27 @@ SysResult sys_chmod(Thread *thread, ptr<char> path, sint mode);
 SysResult sys_chown(Thread *thread, ptr<char> path, sint uid, sint gid);
 SysResult sys_obreak(Thread *thread, ptr<char> nsize);
 SysResult sys_getpid(Thread *thread);
-SysResult sys_mount(Thread *thread, ptr<char> type, ptr<char> path, sint flags, caddr_t data);
+SysResult sys_mount(Thread *thread, ptr<char> type, ptr<char> path, sint flags,
+                    caddr_t data);
 SysResult sys_unmount(Thread *thread, ptr<char> path, sint flags);
 SysResult sys_setuid(Thread *thread, uid_t uid);
 SysResult sys_getuid(Thread *thread);
 SysResult sys_geteuid(Thread *thread);
-SysResult sys_ptrace(Thread *thread, sint req, pid_t pid, caddr_t addr, sint data);
-SysResult sys_recvmsg(Thread *thread, sint s, ptr<struct msghdr> msg, sint flags);
-SysResult sys_sendmsg(Thread *thread, sint s, ptr<struct msghdr> msg, sint flags);
-SysResult sys_recvfrom(Thread *thread, sint s, caddr_t buf, size_t len, sint flags, ptr<struct sockaddr> from, ptr<uint32_t> fromlenaddr);
-SysResult sys_accept(Thread *thread, sint s, ptr<struct sockaddr> from, ptr<uint32_t> fromlenaddr);
-SysResult sys_getpeername(Thread *thread, sint fdes, ptr<struct sockaddr> asa, ptr<uint32_t> alen);
-SysResult sys_getsockname(Thread *thread, sint fdes, ptr<struct sockaddr> asa, ptr<uint32_t> alen);
+SysResult sys_ptrace(Thread *thread, sint req, pid_t pid, caddr_t addr,
+                     sint data);
+SysResult sys_recvmsg(Thread *thread, sint s, ptr<struct msghdr> msg,
+                      sint flags);
+SysResult sys_sendmsg(Thread *thread, sint s, ptr<struct msghdr> msg,
+                      sint flags);
+SysResult sys_recvfrom(Thread *thread, sint s, caddr_t buf, size_t len,
+                       sint flags, ptr<struct sockaddr> from,
+                       ptr<uint32_t> fromlenaddr);
+SysResult sys_accept(Thread *thread, sint s, ptr<struct sockaddr> from,
+                     ptr<uint32_t> fromlenaddr);
+SysResult sys_getpeername(Thread *thread, sint fdes, ptr<struct sockaddr> asa,
+                          ptr<uint32_t> alen);
+SysResult sys_getsockname(Thread *thread, sint fdes, ptr<struct sockaddr> asa,
+                          ptr<uint32_t> alen);
 SysResult sys_access(Thread *thread, ptr<char> path, sint flags);
 SysResult sys_chflags(Thread *thread, ptr<char> path, sint flags);
 SysResult sys_fchflags(Thread *thread, sint fd, sint flags);
@@ -55,8 +65,10 @@ SysResult sys_getppid(Thread *thread);
 SysResult sys_dup(Thread *thread, uint fd);
 SysResult sys_pipe(Thread *thread);
 SysResult sys_getegid(Thread *thread);
-SysResult sys_profil(Thread *thread, caddr_t samples, size_t size, size_t offset, uint scale);
-SysResult sys_ktrace(Thread *thread, ptr<const char> fname, sint ops, sint facs, sint pit);
+SysResult sys_profil(Thread *thread, caddr_t samples, size_t size,
+                     size_t offset, uint scale);
+SysResult sys_ktrace(Thread *thread, ptr<const char> fname, sint ops, sint facs,
+                     sint pit);
 SysResult sys_getgid(Thread *thread);
 SysResult sys_getlogin(Thread *thread, ptr<char> namebuf, uint namelen);
 SysResult sys_setlogin(Thread *thread, ptr<char> namebuf);
@@ -66,8 +78,10 @@ SysResult sys_ioctl(Thread *thread, sint fd, ulong com, caddr_t data);
 SysResult sys_reboot(Thread *thread, sint opt);
 SysResult sys_revoke(Thread *thread, ptr<char> path);
 SysResult sys_symlink(Thread *thread, ptr<char> path, ptr<char> link);
-SysResult sys_readlink(Thread *thread, ptr<char> path, ptr<char> buf, size_t count);
-SysResult sys_execve(Thread *thread, ptr<char> fname, ptr<ptr<char>> argv, ptr<ptr<char>> envv);
+SysResult sys_readlink(Thread *thread, ptr<char> path, ptr<char> buf,
+                       size_t count);
+SysResult sys_execve(Thread *thread, ptr<char> fname, ptr<ptr<char>> argv,
+                     ptr<ptr<char>> envv);
 SysResult sys_umask(Thread *thread, sint newmask);
 SysResult sys_chroot(Thread *thread, ptr<char> path);
 SysResult sys_msync(Thread *thread, ptr<void> addr, size_t len, sint flags);
@@ -76,34 +90,45 @@ SysResult sys_sbrk(Thread *thread, sint incr);
 SysResult sys_sstk(Thread *thread, sint incr);
 SysResult sys_ovadvise(Thread *thread, sint anom);
 SysResult sys_munmap(Thread *thread, ptr<void> addr, size_t len);
-SysResult sys_mprotect(Thread *thread, ptr<const void> addr, size_t len, sint prot);
+SysResult sys_mprotect(Thread *thread, ptr<const void> addr, size_t len,
+                       sint prot);
 SysResult sys_madvise(Thread *thread, ptr<void> addr, size_t len, sint behav);
-SysResult sys_mincore(Thread *thread, ptr<const void> addr, size_t len, ptr<char> vec);
+SysResult sys_mincore(Thread *thread, ptr<const void> addr, size_t len,
+                      ptr<char> vec);
 SysResult sys_getgroups(Thread *thread, uint gidsetsize, ptr<gid_t> gidset);
 SysResult sys_setgroups(Thread *thread, uint gidsetsize, ptr<gid_t> gidset);
 SysResult sys_getpgrp(Thread *thread);
 SysResult sys_setpgid(Thread *thread, sint pid, sint pgid);
-SysResult sys_setitimer(Thread *thread, uint which, ptr<struct itimerval> itv, ptr<struct itimerval> oitv);
+SysResult sys_setitimer(Thread *thread, uint which, ptr<struct itimerval> itv,
+                        ptr<struct itimerval> oitv);
 SysResult sys_swapon(Thread *thread, ptr<char> name);
 SysResult sys_getitimer(Thread *thread, uint which, ptr<struct itimerval> itv);
 SysResult sys_getdtablesize(Thread *thread);
 SysResult sys_dup2(Thread *thread, uint from, uint to);
 SysResult sys_fcntl(Thread *thread, sint fd, sint cmd, slong arg);
-SysResult sys_select(Thread *thread, sint nd, ptr<struct fd_set_t> in, ptr<struct fd_set_t> out, ptr<struct fd_set_t> ex, ptr<struct timeval> tv);
+SysResult sys_select(Thread *thread, sint nd, ptr<struct fd_set_t> in,
+                     ptr<struct fd_set_t> out, ptr<struct fd_set_t> ex,
+                     ptr<struct timeval> tv);
 SysResult sys_fsync(Thread *thread, sint fd);
 SysResult sys_setpriority(Thread *thread, sint which, sint who, sint prio);
 SysResult sys_socket(Thread *thread, sint domain, sint type, sint protocol);
 SysResult sys_connect(Thread *thread, sint s, caddr_t name, sint namelen);
 SysResult sys_getpriority(Thread *thread, sint which, sint who);
 SysResult sys_bind(Thread *thread, sint s, caddr_t name, sint namelen);
-SysResult sys_setsockopt(Thread *thread, sint s, sint level, sint name, caddr_t val, sint valsize);
+SysResult sys_setsockopt(Thread *thread, sint s, sint level, sint name,
+                         caddr_t val, sint valsize);
 SysResult sys_listen(Thread *thread, sint s, sint backlog);
-SysResult sys_gettimeofday(Thread *thread, ptr<struct timeval> tp, ptr<struct timezone> tzp);
+SysResult sys_gettimeofday(Thread *thread, ptr<struct timeval> tp,
+                           ptr<struct timezone> tzp);
 SysResult sys_getrusage(Thread *thread, sint who, ptr<struct rusage> rusage);
-SysResult sys_getsockopt(Thread *thread, sint s, sint level, sint name, caddr_t val, ptr<sint> avalsize);
-SysResult sys_readv(Thread *thread, sint fd, ptr<struct iovec> iovp, uint iovcnt);
-SysResult sys_writev(Thread *thread, sint fd, ptr<struct iovec> iovp, uint iovcnt);
-SysResult sys_settimeofday(Thread *thread, ptr<struct timeval> tp, ptr<struct timezone> tzp);
+SysResult sys_getsockopt(Thread *thread, sint s, sint level, sint name,
+                         caddr_t val, ptr<sint> avalsize);
+SysResult sys_readv(Thread *thread, sint fd, ptr<struct iovec> iovp,
+                    uint iovcnt);
+SysResult sys_writev(Thread *thread, sint fd, ptr<struct iovec> iovp,
+                     uint iovcnt);
+SysResult sys_settimeofday(Thread *thread, ptr<struct timeval> tp,
+                           ptr<struct timezone> tzp);
 SysResult sys_fchown(Thread *thread, sint fd, sint uid, sint gid);
 SysResult sys_fchmod(Thread *thread, sint fd, sint mode);
 SysResult sys_setreuid(Thread *thread, sint ruid, sint euid);
@@ -111,26 +136,36 @@ SysResult sys_setregid(Thread *thread, sint rgid, sint egid);
 SysResult sys_rename(Thread *thread, ptr<char> from, ptr<char> to);
 SysResult sys_flock(Thread *thread, sint fd, sint how);
 SysResult sys_mkfifo(Thread *thread, ptr<char> path, sint mode);
-SysResult sys_sendto(Thread *thread, sint s, caddr_t buf, size_t len, sint flags, caddr_t to, sint tolen);
+SysResult sys_sendto(Thread *thread, sint s, caddr_t buf, size_t len,
+                     sint flags, caddr_t to, sint tolen);
 SysResult sys_shutdown(Thread *thread, sint s, sint how);
-SysResult sys_socketpair(Thread *thread, sint domain, sint type, sint protocol, ptr<sint> rsv);
+SysResult sys_socketpair(Thread *thread, sint domain, sint type, sint protocol,
+                         ptr<sint> rsv);
 SysResult sys_mkdir(Thread *thread, ptr<char> path, sint mode);
 SysResult sys_rmdir(Thread *thread, ptr<char> path);
 SysResult sys_utimes(Thread *thread, ptr<char> path, ptr<struct timeval> tptr);
-SysResult sys_adjtime(Thread *thread, ptr<struct timeval> delta, ptr<struct timeval> olddelta);
+SysResult sys_adjtime(Thread *thread, ptr<struct timeval> delta,
+                      ptr<struct timeval> olddelta);
 SysResult sys_setsid(Thread *thread);
-SysResult sys_quotactl(Thread *thread, ptr<char> path, sint cmd, sint uid, caddr_t arg);
-SysResult sys_nlm_syscall(Thread *thread, sint debug_level, sint grace_period, sint addr_count, ptr<ptr<char>> addrs);
+SysResult sys_quotactl(Thread *thread, ptr<char> path, sint cmd, sint uid,
+                       caddr_t arg);
+SysResult sys_nlm_syscall(Thread *thread, sint debug_level, sint grace_period,
+                          sint addr_count, ptr<ptr<char>> addrs);
 SysResult sys_nfssvc(Thread *thread, sint flag, caddr_t argp);
 SysResult sys_lgetfh(Thread *thread, ptr<char> fname, ptr<struct fhandle> fhp);
 SysResult sys_getfh(Thread *thread, ptr<char> fname, ptr<struct fhandle> fhp);
 SysResult sys_sysarch(Thread *thread, sint op, ptr<char> parms);
-SysResult sys_rtprio(Thread *thread, sint function, pid_t pid, ptr<struct rtprio> rtp);
-SysResult sys_semsys(Thread *thread, sint which, sint a2, sint a3, sint a4, sint a5);
-SysResult sys_msgsys(Thread *thread, sint which, sint a2, sint a3, sint a4, sint a5, sint a6);
+SysResult sys_rtprio(Thread *thread, sint function, pid_t pid,
+                     ptr<struct rtprio> rtp);
+SysResult sys_semsys(Thread *thread, sint which, sint a2, sint a3, sint a4,
+                     sint a5);
+SysResult sys_msgsys(Thread *thread, sint which, sint a2, sint a3, sint a4,
+                     sint a5, sint a6);
 SysResult sys_shmsys(Thread *thread, sint which, sint a2, sint a3, sint a4);
-SysResult sys_freebsd6_pread(Thread *thread, sint fd, ptr<void> buf, size_t nbyte, sint pad, off_t offset);
-SysResult sys_freebsd6_pwrite(Thread *thread, sint fd, ptr<const void> buf, size_t nbyte, sint pad, off_t offset);
+SysResult sys_freebsd6_pread(Thread *thread, sint fd, ptr<void> buf,
+                             size_t nbyte, sint pad, off_t offset);
+SysResult sys_freebsd6_pwrite(Thread *thread, sint fd, ptr<const void> buf,
+                              size_t nbyte, sint pad, off_t offset);
 SysResult sys_setfib(Thread *thread, sint fib);
 SysResult sys_ntp_adjtime(Thread *thread, ptr<struct timex> tp);
 SysResult sys_setgid(Thread *thread, gid_t gid);
@@ -143,54 +178,82 @@ SysResult sys_pathconf(Thread *thread, ptr<char> path, sint name);
 SysResult sys_fpathconf(Thread *thread, sint fd, sint name);
 SysResult sys_getrlimit(Thread *thread, uint which, ptr<struct rlimit> rlp);
 SysResult sys_setrlimit(Thread *thread, uint which, ptr<struct rlimit> rlp);
-SysResult sys_getdirentries(Thread *thread, sint fd, ptr<char> buf, uint count, ptr<slong> basep);
-SysResult sys_freebsd6_mmap(Thread *thread, caddr_t addr, size_t len, sint prot, sint flags, sint fd, sint pad, off_t pos);
-SysResult sys_freebsd6_lseek(Thread *thread, sint fd, sint pad, off_t offset, sint whence);
-SysResult sys_freebsd6_truncate(Thread *thread, ptr<char> path, sint pad, off_t length);
-SysResult sys_freebsd6_ftruncate(Thread *thread, sint fd, sint pad, off_t length);
-SysResult sys___sysctl(Thread *thread, ptr<sint> name, uint namelen, ptr<void> old, ptr<size_t> oldenp, ptr<void> new_, size_t newlen);
+SysResult sys_getdirentries(Thread *thread, sint fd, ptr<char> buf, uint count,
+                            ptr<slong> basep);
+SysResult sys_freebsd6_mmap(Thread *thread, caddr_t addr, size_t len, sint prot,
+                            sint flags, sint fd, sint pad, off_t pos);
+SysResult sys_freebsd6_lseek(Thread *thread, sint fd, sint pad, off_t offset,
+                             sint whence);
+SysResult sys_freebsd6_truncate(Thread *thread, ptr<char> path, sint pad,
+                                off_t length);
+SysResult sys_freebsd6_ftruncate(Thread *thread, sint fd, sint pad,
+                                 off_t length);
+SysResult sys___sysctl(Thread *thread, ptr<sint> name, uint namelen,
+                       ptr<void> old, ptr<size_t> oldenp, ptr<void> new_,
+                       size_t newlen);
 SysResult sys_mlock(Thread *thread, ptr<const void> addr, size_t len);
 SysResult sys_munlock(Thread *thread, ptr<const void> addr, size_t len);
 SysResult sys_undelete(Thread *thread, ptr<char> path);
 SysResult sys_futimes(Thread *thread, sint fd, ptr<struct timeval> tptr);
 SysResult sys_getpgid(Thread *thread, pid_t pid);
-SysResult sys_poll(Thread *thread, ptr<struct pollfd> fds, uint nfds, sint timeout);
+SysResult sys_poll(Thread *thread, ptr<struct pollfd> fds, uint nfds,
+                   sint timeout);
 SysResult sys_semget(Thread *thread, key_t key, sint nsems, sint semflg);
-SysResult sys_semop(Thread *thread, sint semid, ptr<struct sembuf> sops, size_t nspos);
+SysResult sys_semop(Thread *thread, sint semid, ptr<struct sembuf> sops,
+                    size_t nspos);
 SysResult sys_msgget(Thread *thread, key_t key, sint msgflg);
-SysResult sys_msgsnd(Thread *thread, sint msqid, ptr<const void> msgp, size_t msgsz, sint msgflg);
-SysResult sys_msgrcv(Thread *thread, sint msqid, ptr<void> msgp, size_t msgsz, slong msgtyp, sint msgflg);
-SysResult sys_shmat(Thread *thread, sint shmid, ptr<const void> shmaddr, sint shmflg);
+SysResult sys_msgsnd(Thread *thread, sint msqid, ptr<const void> msgp,
+                     size_t msgsz, sint msgflg);
+SysResult sys_msgrcv(Thread *thread, sint msqid, ptr<void> msgp, size_t msgsz,
+                     slong msgtyp, sint msgflg);
+SysResult sys_shmat(Thread *thread, sint shmid, ptr<const void> shmaddr,
+                    sint shmflg);
 SysResult sys_shmdt(Thread *thread, ptr<const void> shmaddr);
 SysResult sys_shmget(Thread *thread, key_t key, size_t size, sint shmflg);
-SysResult sys_clock_gettime(Thread *thread, clockid_t clock_id, ptr<struct timespec> tp);
-SysResult sys_clock_settime(Thread *thread, clockid_t clock_id, ptr<const struct timespec> tp);
-SysResult sys_clock_getres(Thread *thread, clockid_t clock_id, ptr<struct timespec> tp);
-SysResult sys_ktimer_create(Thread *thread, clockid_t clock_id, ptr<struct sigevent> evp, ptr<sint> timerid);
+SysResult sys_clock_gettime(Thread *thread, clockid_t clock_id,
+                            ptr<struct timespec> tp);
+SysResult sys_clock_settime(Thread *thread, clockid_t clock_id,
+                            ptr<const struct timespec> tp);
+SysResult sys_clock_getres(Thread *thread, clockid_t clock_id,
+                           ptr<struct timespec> tp);
+SysResult sys_ktimer_create(Thread *thread, clockid_t clock_id,
+                            ptr<struct sigevent> evp, ptr<sint> timerid);
 SysResult sys_ktimer_delete(Thread *thread, sint timerid);
-SysResult sys_ktimer_settime(Thread *thread, sint timerid, sint flags, ptr<const struct itimerspec> value, ptr<struct itimerspec> ovalue);
-SysResult sys_ktimer_gettime(Thread *thread, sint timerid, ptr<struct itimerspec> value);
+SysResult sys_ktimer_settime(Thread *thread, sint timerid, sint flags,
+                             ptr<const struct itimerspec> value,
+                             ptr<struct itimerspec> ovalue);
+SysResult sys_ktimer_gettime(Thread *thread, sint timerid,
+                             ptr<struct itimerspec> value);
 SysResult sys_ktimer_getoverrun(Thread *thread, sint timerid);
-SysResult sys_nanosleep(Thread *thread, ptr<const struct timespec> rqtp, ptr<struct timespec> rmtp);
+SysResult sys_nanosleep(Thread *thread, ptr<const struct timespec> rqtp,
+                        ptr<struct timespec> rmtp);
 SysResult sys_ntp_gettime(Thread *thread, ptr<struct ntptimeval> ntvp);
-SysResult sys_minherit(Thread *thread, ptr<void> addr, size_t len, sint inherit);
+SysResult sys_minherit(Thread *thread, ptr<void> addr, size_t len,
+                       sint inherit);
 SysResult sys_rfork(Thread *thread, sint flags);
-SysResult sys_openbsd_poll(Thread *thread, ptr<struct pollfd> fds, uint nfds, sint timeout);
+SysResult sys_openbsd_poll(Thread *thread, ptr<struct pollfd> fds, uint nfds,
+                           sint timeout);
 SysResult sys_issetugid(Thread *thread);
 SysResult sys_lchown(Thread *thread, ptr<char> path, sint uid, sint gid);
 SysResult sys_aio_read(Thread *thread, ptr<struct aiocb> aiocbp);
 SysResult sys_aio_write(Thread *thread, ptr<struct aiocb> aiocbp);
-SysResult sys_lio_listio(Thread *thread, sint mode, ptr<cptr<struct aiocb>> aiocbp, sint nent, ptr<struct sigevent> sig);
+SysResult sys_lio_listio(Thread *thread, sint mode,
+                         ptr<cptr<struct aiocb>> aiocbp, sint nent,
+                         ptr<struct sigevent> sig);
 SysResult sys_getdents(Thread *thread, sint fd, ptr<char> buf, size_t count);
 SysResult sys_lchmod(Thread *thread, ptr<char> path, mode_t mode);
 SysResult sys_lutimes(Thread *thread, ptr<char> path, ptr<struct timeval> tptr);
 SysResult sys_nstat(Thread *thread, ptr<char> path, ptr<struct nstat> ub);
 SysResult sys_nfstat(Thread *thread, sint fd, ptr<struct nstat> sb);
 SysResult sys_nlstat(Thread *thread, ptr<char> path, ptr<struct nstat> ub);
-SysResult sys_preadv(Thread *thread, sint fd, ptr<struct iovec> iovp, uint iovcnt, off_t offset);
-SysResult sys_pwritev(Thread *thread, sint fd, ptr<struct iovec> iovp, uint iovcnt, off_t offset);
-SysResult sys_fhopen(Thread *thread, ptr<const struct fhandle> u_fhp, sint flags);
-SysResult sys_fhstat(Thread *thread, ptr<const struct fhandle> u_fhp, ptr<struct stat> sb);
+SysResult sys_preadv(Thread *thread, sint fd, ptr<struct iovec> iovp,
+                     uint iovcnt, off_t offset);
+SysResult sys_pwritev(Thread *thread, sint fd, ptr<struct iovec> iovp,
+                      uint iovcnt, off_t offset);
+SysResult sys_fhopen(Thread *thread, ptr<const struct fhandle> u_fhp,
+                     sint flags);
+SysResult sys_fhstat(Thread *thread, ptr<const struct fhandle> u_fhp,
+                     ptr<struct stat> sb);
 SysResult sys_modnext(Thread *thread, sint modid);
 SysResult sys_modstat(Thread *thread, sint modid, ptr<struct module_stat> stat);
 SysResult sys_modfnext(Thread *thread, sint modid);
@@ -199,116 +262,188 @@ SysResult sys_kldload(Thread *thread, ptr<const char> file);
 SysResult sys_kldunload(Thread *thread, sint fileid);
 SysResult sys_kldfind(Thread *thread, ptr<const char> name);
 SysResult sys_kldnext(Thread *thread, sint fileid);
-SysResult sys_kldstat(Thread *thread, sint fileid, ptr<struct kld_file_stat> stat);
+SysResult sys_kldstat(Thread *thread, sint fileid,
+                      ptr<struct kld_file_stat> stat);
 SysResult sys_kldfirstmod(Thread *thread, sint fileid);
 SysResult sys_getsid(Thread *thread, pid_t pid);
 SysResult sys_setresuid(Thread *thread, uid_t ruid, uid_t euid, uid_t suid);
 SysResult sys_setresgid(Thread *thread, gid_t rgid, gid_t egid, gid_t sgid);
 SysResult sys_aio_return(Thread *thread, ptr<struct aiocb> aiocbp);
-SysResult sys_aio_suspend(Thread *thread, ptr<struct aiocb> aiocbp, sint nent, ptr<const struct timespec> timeout);
+SysResult sys_aio_suspend(Thread *thread, ptr<struct aiocb> aiocbp, sint nent,
+                          ptr<const struct timespec> timeout);
 SysResult sys_aio_cancel(Thread *thread, sint fd, ptr<struct aiocb> aiocbp);
 SysResult sys_aio_error(Thread *thread, ptr<struct aiocb> aiocbp);
 SysResult sys_oaio_read(Thread *thread, ptr<struct aiocb> aiocbp);
 SysResult sys_oaio_write(Thread *thread, ptr<struct aiocb> aiocbp);
-SysResult sys_olio_listio(Thread *thread, sint mode, ptr<cptr<struct aiocb>> acb_list, sint nent, ptr<struct osigevent> sig);
+SysResult sys_olio_listio(Thread *thread, sint mode,
+                          ptr<cptr<struct aiocb>> acb_list, sint nent,
+                          ptr<struct osigevent> sig);
 SysResult sys_yield(Thread *thread);
 SysResult sys_mlockall(Thread *thread, sint how);
 SysResult sys_munlockall(Thread *thread);
 SysResult sys___getcwd(Thread *thread, ptr<char> buf, uint buflen);
-SysResult sys_sched_setparam(Thread *thread, pid_t pid, ptr<const struct sched_param> param);
-SysResult sys_sched_getparam(Thread *thread, pid_t pid, ptr<struct sched_param> param);
-SysResult sys_sched_setscheduler(Thread *thread, pid_t pid, sint policy, ptr<const struct sched_param> param);
+SysResult sys_sched_setparam(Thread *thread, pid_t pid,
+                             ptr<const struct sched_param> param);
+SysResult sys_sched_getparam(Thread *thread, pid_t pid,
+                             ptr<struct sched_param> param);
+SysResult sys_sched_setscheduler(Thread *thread, pid_t pid, sint policy,
+                                 ptr<const struct sched_param> param);
 SysResult sys_sched_getscheduler(Thread *thread, pid_t pid);
 SysResult sys_sched_yield(Thread *thread);
 SysResult sys_sched_get_priority_max(Thread *thread, sint policy);
 SysResult sys_sched_get_priority_min(Thread *thread, sint policy);
-SysResult sys_sched_rr_get_interval(Thread *thread, pid_t pid, ptr<struct timespec> interval);
+SysResult sys_sched_rr_get_interval(Thread *thread, pid_t pid,
+                                    ptr<struct timespec> interval);
 SysResult sys_utrace(Thread *thread, ptr<const void> addr, size_t len);
 SysResult sys_kldsym(Thread *thread, sint fileid, sint cmd, ptr<void> data);
 SysResult sys_jail(Thread *thread, ptr<struct jail> jail);
-SysResult sys_nnpfs_syscall(Thread *thread, sint operation, ptr<char> a_pathP, sint opcode, ptr<void> a_paramsP, sint a_followSymlinks);
-SysResult sys_sigprocmask(Thread *thread, sint how, ptr<uint64_t> set, ptr<uint64_t> oset);
+SysResult sys_nnpfs_syscall(Thread *thread, sint operation, ptr<char> a_pathP,
+                            sint opcode, ptr<void> a_paramsP,
+                            sint a_followSymlinks);
+SysResult sys_sigprocmask(Thread *thread, sint how, ptr<uint64_t> set,
+                          ptr<uint64_t> oset);
 SysResult sys_sigsuspend(Thread *thread, ptr<const struct sigset> set);
 SysResult sys_sigpending(Thread *thread, ptr<struct sigset> set);
-SysResult sys_sigtimedwait(Thread *thread, ptr<const struct sigset> set, ptr<struct siginfo> info, ptr<const struct timespec> timeout);
-SysResult sys_sigwaitinfo(Thread *thread, ptr<const struct sigset> set, ptr<struct siginfo> info);
-SysResult sys___acl_get_file(Thread *thread, ptr<char> path, acl_type_t type, ptr<struct acl> aclp);
-SysResult sys___acl_set_file(Thread *thread, ptr<char> path, acl_type_t type, ptr<struct acl> aclp);
-SysResult sys___acl_get_fd(Thread *thread, sint filedes, acl_type_t type, ptr<struct acl> aclp);
-SysResult sys___acl_set_fd(Thread *thread, sint filedes, acl_type_t type, ptr<struct acl> aclp);
-SysResult sys___acl_delete_file(Thread *thread, ptr<char> path, acl_type_t type);
+SysResult sys_sigtimedwait(Thread *thread, ptr<const struct sigset> set,
+                           ptr<struct siginfo> info,
+                           ptr<const struct timespec> timeout);
+SysResult sys_sigwaitinfo(Thread *thread, ptr<const struct sigset> set,
+                          ptr<struct siginfo> info);
+SysResult sys___acl_get_file(Thread *thread, ptr<char> path, acl_type_t type,
+                             ptr<struct acl> aclp);
+SysResult sys___acl_set_file(Thread *thread, ptr<char> path, acl_type_t type,
+                             ptr<struct acl> aclp);
+SysResult sys___acl_get_fd(Thread *thread, sint filedes, acl_type_t type,
+                           ptr<struct acl> aclp);
+SysResult sys___acl_set_fd(Thread *thread, sint filedes, acl_type_t type,
+                           ptr<struct acl> aclp);
+SysResult sys___acl_delete_file(Thread *thread, ptr<char> path,
+                                acl_type_t type);
 SysResult sys___acl_delete_fd(Thread *thread, sint filedes, acl_type_t type);
-SysResult sys___acl_aclcheck_file(Thread *thread, ptr<char> path, acl_type_t type, ptr<struct acl> aclp);
-SysResult sys___acl_aclcheck_fd(Thread *thread, sint filedes, acl_type_t type, ptr<struct acl> aclp);
-SysResult sys_extattrctl(Thread *thread, ptr<char> path, char cmd, ptr<const char> filename, sint attrnamespace, ptr<const char> attrname);
-SysResult sys_extattr_set_file(Thread *thread, ptr<char> path, sint attrnamespace, ptr<const char> filename, ptr<void> data, size_t nbytes);
-SysResult sys_extattr_get_file(Thread *thread, ptr<char> path, sint attrnamespace, ptr<const char> filename, ptr<void> data, size_t nbytes);
-SysResult sys_extattr_delete_file(Thread *thread, ptr<char> path, sint attrnamespace, ptr<const char> attrname);
-SysResult sys_aio_waitcomplete(Thread *thread, ptr<ptr<struct aiocb>> aiocbp, ptr<struct timespec> timeout);
-SysResult sys_getresuid(Thread *thread, ptr<uid_t> ruid, ptr<uid_t> euid, ptr<uid_t> suid);
-SysResult sys_getresgid(Thread *thread, ptr<gid_t> rgid, ptr<gid_t> egid, ptr<gid_t> sgid);
+SysResult sys___acl_aclcheck_file(Thread *thread, ptr<char> path,
+                                  acl_type_t type, ptr<struct acl> aclp);
+SysResult sys___acl_aclcheck_fd(Thread *thread, sint filedes, acl_type_t type,
+                                ptr<struct acl> aclp);
+SysResult sys_extattrctl(Thread *thread, ptr<char> path, char cmd,
+                         ptr<const char> filename, sint attrnamespace,
+                         ptr<const char> attrname);
+SysResult sys_extattr_set_file(Thread *thread, ptr<char> path,
+                               sint attrnamespace, ptr<const char> filename,
+                               ptr<void> data, size_t nbytes);
+SysResult sys_extattr_get_file(Thread *thread, ptr<char> path,
+                               sint attrnamespace, ptr<const char> filename,
+                               ptr<void> data, size_t nbytes);
+SysResult sys_extattr_delete_file(Thread *thread, ptr<char> path,
+                                  sint attrnamespace, ptr<const char> attrname);
+SysResult sys_aio_waitcomplete(Thread *thread, ptr<ptr<struct aiocb>> aiocbp,
+                               ptr<struct timespec> timeout);
+SysResult sys_getresuid(Thread *thread, ptr<uid_t> ruid, ptr<uid_t> euid,
+                        ptr<uid_t> suid);
+SysResult sys_getresgid(Thread *thread, ptr<gid_t> rgid, ptr<gid_t> egid,
+                        ptr<gid_t> sgid);
 SysResult sys_kqueue(Thread *thread);
-SysResult sys_kevent(Thread *thread, sint fd, ptr<struct kevent> changelist, sint nchanges, ptr<struct kevent> eventlist, sint nevents, ptr<const struct timespec> timeout);
-SysResult sys_extattr_set_fd(Thread *thread, sint fd, sint attrnamespace, ptr<const char> attrname, ptr<void> data, size_t nbytes);
-SysResult sys_extattr_get_fd(Thread *thread, sint fd, sint attrnamespace, ptr<const char> attrname, ptr<void> data, size_t nbytes);
-SysResult sys_extattr_delete_fd(Thread *thread, sint fd, sint attrnamespace, ptr<const char> attrname);
+SysResult sys_kevent(Thread *thread, sint fd, ptr<struct kevent> changelist,
+                     sint nchanges, ptr<struct kevent> eventlist, sint nevents,
+                     ptr<const struct timespec> timeout);
+SysResult sys_extattr_set_fd(Thread *thread, sint fd, sint attrnamespace,
+                             ptr<const char> attrname, ptr<void> data,
+                             size_t nbytes);
+SysResult sys_extattr_get_fd(Thread *thread, sint fd, sint attrnamespace,
+                             ptr<const char> attrname, ptr<void> data,
+                             size_t nbytes);
+SysResult sys_extattr_delete_fd(Thread *thread, sint fd, sint attrnamespace,
+                                ptr<const char> attrname);
 SysResult sys___setugid(Thread *thread, sint flags);
 SysResult sys_eaccess(Thread *thread, ptr<char> path, sint flags);
-SysResult sys_afs3_syscall(Thread *thread, slong syscall, slong param1, slong param2, slong param3, slong param4, slong param5, slong param6);
-SysResult sys_nmount(Thread *thread, ptr<struct iovec> iovp, uint iovcnt, sint flags);
+SysResult sys_afs3_syscall(Thread *thread, slong syscall, slong param1,
+                           slong param2, slong param3, slong param4,
+                           slong param5, slong param6);
+SysResult sys_nmount(Thread *thread, ptr<struct iovec> iovp, uint iovcnt,
+                     sint flags);
 SysResult sys___mac_get_proc(Thread *thread, ptr<struct mac> mac_p);
 SysResult sys___mac_set_proc(Thread *thread, ptr<struct mac> mac_p);
 SysResult sys___mac_get_fd(Thread *thread, sint fd, ptr<struct mac> mac_p);
-SysResult sys___mac_get_file(Thread *thread, ptr<const char> path, ptr<struct mac> mac_p);
+SysResult sys___mac_get_file(Thread *thread, ptr<const char> path,
+                             ptr<struct mac> mac_p);
 SysResult sys___mac_set_fd(Thread *thread, sint fd, ptr<struct mac> mac_p);
-SysResult sys___mac_set_file(Thread *thread, ptr<const char> path, ptr<struct mac> mac_p);
-SysResult sys_kenv(Thread *thread, sint what, ptr<const char> name, ptr<char> value, sint len);
+SysResult sys___mac_set_file(Thread *thread, ptr<const char> path,
+                             ptr<struct mac> mac_p);
+SysResult sys_kenv(Thread *thread, sint what, ptr<const char> name,
+                   ptr<char> value, sint len);
 SysResult sys_lchflags(Thread *thread, ptr<const char> path, sint flags);
 SysResult sys_uuidgen(Thread *thread, ptr<struct uuid> store, sint count);
-SysResult sys_sendfile(Thread *thread, sint fd, sint s, off_t offset, size_t nbytes, ptr<struct sf_hdtr> hdtr, ptr<off_t> sbytes, sint flags);
-SysResult sys_mac_syscall(Thread *thread, ptr<const char> policy, sint call, ptr<void> arg);
-SysResult sys_getfsstat(Thread *thread, ptr<struct statfs> buf, slong bufsize, sint flags);
+SysResult sys_sendfile(Thread *thread, sint fd, sint s, off_t offset,
+                       size_t nbytes, ptr<struct sf_hdtr> hdtr,
+                       ptr<off_t> sbytes, sint flags);
+SysResult sys_mac_syscall(Thread *thread, ptr<const char> policy, sint call,
+                          ptr<void> arg);
+SysResult sys_getfsstat(Thread *thread, ptr<struct statfs> buf, slong bufsize,
+                        sint flags);
 SysResult sys_statfs(Thread *thread, ptr<char> path, ptr<struct statfs> buf);
 SysResult sys_fstatfs(Thread *thread, sint fd, ptr<struct statfs> buf);
-SysResult sys_fhstatfs(Thread *thread, ptr<const struct fhandle> u_fhp, ptr<struct statfs> buf);
+SysResult sys_fhstatfs(Thread *thread, ptr<const struct fhandle> u_fhp,
+                       ptr<struct statfs> buf);
 SysResult sys_ksem_close(Thread *thread, semid_t id);
 SysResult sys_ksem_post(Thread *thread, semid_t id);
 SysResult sys_ksem_wait(Thread *thread, semid_t id);
 SysResult sys_ksem_trywait(Thread *thread, semid_t id);
 SysResult sys_ksem_init(Thread *thread, ptr<semid_t> idp, uint value);
-SysResult sys_ksem_open(Thread *thread, ptr<semid_t> idp, ptr<const char> name, sint oflag, mode_t mode, uint value);
+SysResult sys_ksem_open(Thread *thread, ptr<semid_t> idp, ptr<const char> name,
+                        sint oflag, mode_t mode, uint value);
 SysResult sys_ksem_unlink(Thread *thread, ptr<const char> name);
 SysResult sys_ksem_getvalue(Thread *thread, semid_t id, ptr<sint> value);
 SysResult sys_ksem_destroy(Thread *thread, semid_t id);
 SysResult sys___mac_get_pid(Thread *thread, pid_t pid, ptr<struct mac> mac_p);
-SysResult sys___mac_get_link(Thread *thread, ptr<const char> path_p, ptr<struct mac> mac_p);
-SysResult sys___mac_set_link(Thread *thread, ptr<const char> path_p, ptr<struct mac> mac_p);
-SysResult sys_extattr_set_link(Thread *thread, ptr<const char> path, sint attrnamespace, ptr<const char> attrname, ptr<void> data, size_t nbytes);
-SysResult sys_extattr_get_link(Thread *thread, ptr<const char> path, sint attrnamespace, ptr<const char> attrname, ptr<void> data, size_t nbytes);
-SysResult sys_extattr_delete_link(Thread *thread, ptr<const char> path, sint attrnamespace, ptr<const char> attrname);
-SysResult sys___mac_execve(Thread *thread, ptr<char> fname, ptr<ptr<char>> argv, ptr<ptr<char>> envv, ptr<struct mac> mac_p);
-SysResult sys_sigaction(Thread *thread, sint sig, ptr<struct sigaction> act, ptr<struct sigaction> oact);
+SysResult sys___mac_get_link(Thread *thread, ptr<const char> path_p,
+                             ptr<struct mac> mac_p);
+SysResult sys___mac_set_link(Thread *thread, ptr<const char> path_p,
+                             ptr<struct mac> mac_p);
+SysResult sys_extattr_set_link(Thread *thread, ptr<const char> path,
+                               sint attrnamespace, ptr<const char> attrname,
+                               ptr<void> data, size_t nbytes);
+SysResult sys_extattr_get_link(Thread *thread, ptr<const char> path,
+                               sint attrnamespace, ptr<const char> attrname,
+                               ptr<void> data, size_t nbytes);
+SysResult sys_extattr_delete_link(Thread *thread, ptr<const char> path,
+                                  sint attrnamespace, ptr<const char> attrname);
+SysResult sys___mac_execve(Thread *thread, ptr<char> fname, ptr<ptr<char>> argv,
+                           ptr<ptr<char>> envv, ptr<struct mac> mac_p);
+SysResult sys_sigaction(Thread *thread, sint sig, ptr<struct sigaction> act,
+                        ptr<struct sigaction> oact);
 SysResult sys_sigreturn(Thread *thread, ptr<struct ucontext> sigcntxp);
 SysResult sys_getcontext(Thread *thread, ptr<struct ucontext> ucp);
 SysResult sys_setcontext(Thread *thread, ptr<struct ucontext> ucp);
-SysResult sys_swapcontext(Thread *thread, ptr<struct ucontext> oucp, ptr<struct ucontext> ucp);
+SysResult sys_swapcontext(Thread *thread, ptr<struct ucontext> oucp,
+                          ptr<struct ucontext> ucp);
 SysResult sys_swapoff(Thread *thread, ptr<const char> name);
-SysResult sys___acl_get_link(Thread *thread, ptr<const char> path, acl_type_t type, ptr<struct acl> aclp);
-SysResult sys___acl_set_link(Thread *thread, ptr<const char> path, acl_type_t type, ptr<struct acl> aclp);
-SysResult sys___acl_delete_link(Thread *thread, ptr<const char> path, acl_type_t type);
-SysResult sys___acl_aclcheck_link(Thread *thread, ptr<const char> path, acl_type_t type, ptr<struct acl> aclp);
-SysResult sys_sigwait(Thread *thread, ptr<const struct sigset> set, ptr<sint> sig);
-SysResult sys_thr_create(Thread *thread, ptr<struct ucontext> ctxt, ptr<slong> arg, sint flags);
+SysResult sys___acl_get_link(Thread *thread, ptr<const char> path,
+                             acl_type_t type, ptr<struct acl> aclp);
+SysResult sys___acl_set_link(Thread *thread, ptr<const char> path,
+                             acl_type_t type, ptr<struct acl> aclp);
+SysResult sys___acl_delete_link(Thread *thread, ptr<const char> path,
+                                acl_type_t type);
+SysResult sys___acl_aclcheck_link(Thread *thread, ptr<const char> path,
+                                  acl_type_t type, ptr<struct acl> aclp);
+SysResult sys_sigwait(Thread *thread, ptr<const struct sigset> set,
+                      ptr<sint> sig);
+SysResult sys_thr_create(Thread *thread, ptr<struct ucontext> ctxt,
+                         ptr<slong> arg, sint flags);
 SysResult sys_thr_exit(Thread *thread, ptr<slong> state);
 SysResult sys_thr_self(Thread *thread, ptr<slong> id);
 SysResult sys_thr_kill(Thread *thread, slong id, sint sig);
 SysResult sys__umtx_lock(Thread *thread, ptr<struct umtx> umtx);
 SysResult sys__umtx_unlock(Thread *thread, ptr<struct umtx> umtx);
 SysResult sys_jail_attach(Thread *thread, sint jid);
-SysResult sys_extattr_list_fd(Thread *thread, sint fd, sint attrnamespace, ptr<void> data, size_t nbytes);
-SysResult sys_extattr_list_file(Thread *thread, ptr<const char> path, sint attrnamespace, ptr<void> data, size_t nbytes);
-SysResult sys_extattr_list_link(Thread *thread, ptr<const char> path, sint attrnamespace, ptr<void> data, size_t nbytes);
-SysResult sys_ksem_timedwait(Thread *thread, semid_t id, ptr<const struct timespec> abstime);
+SysResult sys_extattr_list_fd(Thread *thread, sint fd, sint attrnamespace,
+                              ptr<void> data, size_t nbytes);
+SysResult sys_extattr_list_file(Thread *thread, ptr<const char> path,
+                                sint attrnamespace, ptr<void> data,
+                                size_t nbytes);
+SysResult sys_extattr_list_link(Thread *thread, ptr<const char> path,
+                                sint attrnamespace, ptr<void> data,
+                                size_t nbytes);
+SysResult sys_ksem_timedwait(Thread *thread, semid_t id,
+                             ptr<const struct timespec> abstime);
 SysResult sys_thr_suspend(Thread *thread, ptr<const struct timespec> timeout);
 SysResult sys_thr_wake(Thread *thread, slong id);
 SysResult sys_kldunloadf(Thread *thread, slong fileid, sint flags);
@@ -318,64 +453,119 @@ SysResult sys_getauid(Thread *thread, ptr<uid_t> auid);
 SysResult sys_setauid(Thread *thread, ptr<uid_t> auid);
 SysResult sys_getaudit(Thread *thread, ptr<struct auditinfo> auditinfo);
 SysResult sys_setaudit(Thread *thread, ptr<struct auditinfo> auditinfo);
-SysResult sys_getaudit_addr(Thread *thread, ptr<struct auditinfo_addr> auditinfo_addr, uint length);
-SysResult sys_setaudit_addr(Thread *thread, ptr<struct auditinfo_addr> auditinfo_addr, uint length);
+SysResult sys_getaudit_addr(Thread *thread,
+                            ptr<struct auditinfo_addr> auditinfo_addr,
+                            uint length);
+SysResult sys_setaudit_addr(Thread *thread,
+                            ptr<struct auditinfo_addr> auditinfo_addr,
+                            uint length);
 SysResult sys_auditctl(Thread *thread, ptr<char> path);
-SysResult sys__umtx_op(Thread *thread, ptr<void> obj, sint op, ulong val, ptr<void> uaddr1, ptr<void> uaddr2);
-SysResult sys_thr_new(Thread *thread, ptr<struct thr_param> param, sint param_size);
+SysResult sys__umtx_op(Thread *thread, ptr<void> obj, sint op, ulong val,
+                       ptr<void> uaddr1, ptr<void> uaddr2);
+SysResult sys_thr_new(Thread *thread, ptr<struct thr_param> param,
+                      sint param_size);
 SysResult sys_sigqueue(Thread *thread, pid_t pid, sint signum, ptr<void> value);
-SysResult sys_kmq_open(Thread *thread, ptr<const char> path, sint flags, mode_t mode, ptr<const struct mq_attr> attr);
-SysResult sys_kmq_setattr(Thread *thread, sint mqd, ptr<const struct mq_attr> attr, ptr<struct mq_attr> oattr);
-SysResult sys_kmq_timedreceive(Thread *thread, sint mqd, ptr<const char> msg_ptr, size_t msg_len, ptr<uint> msg_prio, ptr<const struct timespec> abstimeout);
-SysResult sys_kmq_timedsend(Thread *thread, sint mqd, ptr<char> msg_ptr, size_t msg_len, ptr<uint> msg_prio, ptr<const struct timespec> abstimeout);
-SysResult sys_kmq_notify(Thread *thread, sint mqd, ptr<const struct sigevent> sigev);
+SysResult sys_kmq_open(Thread *thread, ptr<const char> path, sint flags,
+                       mode_t mode, ptr<const struct mq_attr> attr);
+SysResult sys_kmq_setattr(Thread *thread, sint mqd,
+                          ptr<const struct mq_attr> attr,
+                          ptr<struct mq_attr> oattr);
+SysResult sys_kmq_timedreceive(Thread *thread, sint mqd,
+                               ptr<const char> msg_ptr, size_t msg_len,
+                               ptr<uint> msg_prio,
+                               ptr<const struct timespec> abstimeout);
+SysResult sys_kmq_timedsend(Thread *thread, sint mqd, ptr<char> msg_ptr,
+                            size_t msg_len, ptr<uint> msg_prio,
+                            ptr<const struct timespec> abstimeout);
+SysResult sys_kmq_notify(Thread *thread, sint mqd,
+                         ptr<const struct sigevent> sigev);
 SysResult sys_kmq_unlink(Thread *thread, ptr<const char> path);
-SysResult sys_abort2(Thread *thread, ptr<const char> why, sint narg, ptr<ptr<void>> args);
+SysResult sys_abort2(Thread *thread, ptr<const char> why, sint narg,
+                     ptr<ptr<void>> args);
 SysResult sys_thr_set_name(Thread *thread, slong id, ptr<const char> name);
 SysResult sys_aio_fsync(Thread *thread, sint op, ptr<struct aiocb> aiocbp);
-SysResult sys_rtprio_thread(Thread *thread, sint function, lwpid_t lwpid, ptr<struct rtprio> rtp);
+SysResult sys_rtprio_thread(Thread *thread, sint function, lwpid_t lwpid,
+                            ptr<struct rtprio> rtp);
 SysResult sys_sctp_peeloff(Thread *thread, sint sd, uint32_t name);
-SysResult sys_sctp_generic_sendmsg(Thread *thread, sint sd, caddr_t msg, sint mlen, caddr_t to, __socklen_t tolen, ptr<struct sctp_sndrcvinfo> sinfo, sint flags);
-SysResult sys_sctp_generic_sendmsg_iov(Thread *thread, sint sd, ptr<struct iovec> iov, sint iovlen, caddr_t to, __socklen_t tolen, ptr<struct sctp_sndrcvinfo> sinfo, sint flags);
-SysResult sys_sctp_generic_recvmsg(Thread *thread, sint sd, ptr<struct iovec> iov, sint iovlen, caddr_t from, __socklen_t fromlen, ptr<struct sctp_sndrcvinfo> sinfo, sint flags);
-SysResult sys_pread(Thread *thread, sint fd, ptr<void> buf, size_t nbyte, off_t offset);
-SysResult sys_pwrite(Thread *thread, sint fd, ptr<const void> buf, size_t nbyte, off_t offset);
-SysResult sys_mmap(Thread *thread, caddr_t addr, size_t len, sint prot, sint flags, sint fd, off_t pos);
+SysResult sys_sctp_generic_sendmsg(Thread *thread, sint sd, caddr_t msg,
+                                   sint mlen, caddr_t to, __socklen_t tolen,
+                                   ptr<struct sctp_sndrcvinfo> sinfo,
+                                   sint flags);
+SysResult sys_sctp_generic_sendmsg_iov(Thread *thread, sint sd,
+                                       ptr<struct iovec> iov, sint iovlen,
+                                       caddr_t to, __socklen_t tolen,
+                                       ptr<struct sctp_sndrcvinfo> sinfo,
+                                       sint flags);
+SysResult sys_sctp_generic_recvmsg(Thread *thread, sint sd,
+                                   ptr<struct iovec> iov, sint iovlen,
+                                   caddr_t from, __socklen_t fromlen,
+                                   ptr<struct sctp_sndrcvinfo> sinfo,
+                                   sint flags);
+SysResult sys_pread(Thread *thread, sint fd, ptr<void> buf, size_t nbyte,
+                    off_t offset);
+SysResult sys_pwrite(Thread *thread, sint fd, ptr<const void> buf, size_t nbyte,
+                     off_t offset);
+SysResult sys_mmap(Thread *thread, caddr_t addr, size_t len, sint prot,
+                   sint flags, sint fd, off_t pos);
 SysResult sys_lseek(Thread *thread, sint fd, off_t offset, sint whence);
 SysResult sys_truncate(Thread *thread, ptr<char> path, off_t length);
 SysResult sys_ftruncate(Thread *thread, sint fd, off_t length);
 SysResult sys_thr_kill2(Thread *thread, pid_t pid, slong id, sint sig);
-SysResult sys_shm_open(Thread *thread, ptr<const char> path, sint flags, mode_t mode);
+SysResult sys_shm_open(Thread *thread, ptr<const char> path, sint flags,
+                       mode_t mode);
 SysResult sys_shm_unlink(Thread *thread, ptr<const char> path);
 SysResult sys_cpuset(Thread *thread, ptr<cpusetid_t> setid);
-SysResult sys_cpuset_setid(Thread *thread, cpuwhich_t which, id_t id, cpusetid_t setid);
-SysResult sys_cpuset_getid(Thread *thread, cpulevel_t level, cpuwhich_t which, id_t id, ptr<cpusetid_t> setid);
-SysResult sys_cpuset_getaffinity(Thread *thread, cpulevel_t level, cpuwhich_t which, id_t id, size_t cpusetsize, ptr<cpuset> mask);
-SysResult sys_cpuset_setaffinity(Thread *thread, cpulevel_t level, cpuwhich_t which, id_t id, size_t cpusetsize, ptr<const cpuset> mask);
-SysResult sys_faccessat(Thread *thread, sint fd, ptr<char> path, sint mode, sint flag);
-SysResult sys_fchmodat(Thread *thread, sint fd, ptr<char> path, mode_t mode, sint flag);
-SysResult sys_fchownat(Thread *thread, sint fd, ptr<char> path, uid_t uid, gid_t gid, sint flag);
-SysResult sys_fexecve(Thread *thread, sint fd, ptr<ptr<char>> argv, ptr<ptr<char>> envv);
-SysResult sys_fstatat(Thread *thread, sint fd, ptr<char> path, ptr<struct stat> buf, sint flag);
-SysResult sys_futimesat(Thread *thread, sint fd, ptr<char> path, ptr<struct timeval> times);
-SysResult sys_linkat(Thread *thread, sint fd1, ptr<char> path1, sint fd2, ptr<char> path2, sint flag);
+SysResult sys_cpuset_setid(Thread *thread, cpuwhich_t which, id_t id,
+                           cpusetid_t setid);
+SysResult sys_cpuset_getid(Thread *thread, cpulevel_t level, cpuwhich_t which,
+                           id_t id, ptr<cpusetid_t> setid);
+SysResult sys_cpuset_getaffinity(Thread *thread, cpulevel_t level,
+                                 cpuwhich_t which, id_t id, size_t cpusetsize,
+                                 ptr<cpuset> mask);
+SysResult sys_cpuset_setaffinity(Thread *thread, cpulevel_t level,
+                                 cpuwhich_t which, id_t id, size_t cpusetsize,
+                                 ptr<const cpuset> mask);
+SysResult sys_faccessat(Thread *thread, sint fd, ptr<char> path, sint mode,
+                        sint flag);
+SysResult sys_fchmodat(Thread *thread, sint fd, ptr<char> path, mode_t mode,
+                       sint flag);
+SysResult sys_fchownat(Thread *thread, sint fd, ptr<char> path, uid_t uid,
+                       gid_t gid, sint flag);
+SysResult sys_fexecve(Thread *thread, sint fd, ptr<ptr<char>> argv,
+                      ptr<ptr<char>> envv);
+SysResult sys_fstatat(Thread *thread, sint fd, ptr<char> path,
+                      ptr<struct stat> buf, sint flag);
+SysResult sys_futimesat(Thread *thread, sint fd, ptr<char> path,
+                        ptr<struct timeval> times);
+SysResult sys_linkat(Thread *thread, sint fd1, ptr<char> path1, sint fd2,
+                     ptr<char> path2, sint flag);
 SysResult sys_mkdirat(Thread *thread, sint fd, ptr<char> path, mode_t mode);
 SysResult sys_mkfifoat(Thread *thread, sint fd, ptr<char> path, mode_t mode);
-SysResult sys_mknodat(Thread *thread, sint fd, ptr<char> path, mode_t mode, dev_t dev);
-SysResult sys_openat(Thread *thread, sint fd, ptr<char> path, sint flag, mode_t mode);
-SysResult sys_readlinkat(Thread *thread, sint fd, ptr<char> path, ptr<char> buf, size_t bufsize);
-SysResult sys_renameat(Thread *thread, sint oldfd, ptr<char> old, sint newfd, ptr<char> new_);
-SysResult sys_symlinkat(Thread *thread, ptr<char> path1, sint fd, ptr<char> path2);
+SysResult sys_mknodat(Thread *thread, sint fd, ptr<char> path, mode_t mode,
+                      dev_t dev);
+SysResult sys_openat(Thread *thread, sint fd, ptr<char> path, sint flag,
+                     mode_t mode);
+SysResult sys_readlinkat(Thread *thread, sint fd, ptr<char> path, ptr<char> buf,
+                         size_t bufsize);
+SysResult sys_renameat(Thread *thread, sint oldfd, ptr<char> old, sint newfd,
+                       ptr<char> new_);
+SysResult sys_symlinkat(Thread *thread, ptr<char> path1, sint fd,
+                        ptr<char> path2);
 SysResult sys_unlinkat(Thread *thread, sint fd, ptr<char> path, sint flag);
 SysResult sys_posix_openpt(Thread *thread, sint flags);
 SysResult sys_gssd_syscall(Thread *thread, ptr<char> path);
-SysResult sys_jail_get(Thread *thread, ptr<struct iovec> iovp, uint iovcnt, sint flags);
-SysResult sys_jail_set(Thread *thread, ptr<struct iovec> iovp, uint iovcnt, sint flags);
+SysResult sys_jail_get(Thread *thread, ptr<struct iovec> iovp, uint iovcnt,
+                       sint flags);
+SysResult sys_jail_set(Thread *thread, ptr<struct iovec> iovp, uint iovcnt,
+                       sint flags);
 SysResult sys_jail_remove(Thread *thread, sint jid);
 SysResult sys_closefrom(Thread *thread, sint lowfd);
-SysResult sys___semctl(Thread *thread, sint semid, sint semnum, sint cmd, ptr<union semun> arg);
-SysResult sys_msgctl(Thread *thread, sint msqid, sint cmd, ptr<struct msqid_ds> buf);
-SysResult sys_shmctl(Thread *thread, sint shmid, sint cmd, ptr<struct shmid_ds> buf);
+SysResult sys___semctl(Thread *thread, sint semid, sint semnum, sint cmd,
+                       ptr<union semun> arg);
+SysResult sys_msgctl(Thread *thread, sint msqid, sint cmd,
+                     ptr<struct msqid_ds> buf);
+SysResult sys_shmctl(Thread *thread, sint shmid, sint cmd,
+                     ptr<struct shmid_ds> buf);
 SysResult sys_lpathconf(Thread *thread, ptr<char> path, sint name);
 SysResult sys_cap_new(Thread *thread, sint fd, uint64_t rights);
 SysResult sys_cap_getrights(Thread *thread, sint fd, ptr<uint64_t> rights);
@@ -384,40 +574,62 @@ SysResult sys_cap_getmode(Thread *thread, ptr<uint> modep);
 SysResult sys_pdfork(Thread *thread, ptr<sint> fdp, sint flags);
 SysResult sys_pdkill(Thread *thread, sint fd, sint signum);
 SysResult sys_pdgetpid(Thread *thread, sint fd, ptr<pid_t> pidp);
-SysResult sys_pselect(Thread *thread, sint nd, ptr<fd_set> in, ptr<fd_set> ou, ptr<fd_set> ex, ptr<const struct timespec> ts, ptr<const sigset_t> sm);
+SysResult sys_pselect(Thread *thread, sint nd, ptr<fd_set> in, ptr<fd_set> ou,
+                      ptr<fd_set> ex, ptr<const struct timespec> ts,
+                      ptr<const sigset_t> sm);
 SysResult sys_getloginclass(Thread *thread, ptr<char> namebuf, size_t namelen);
 SysResult sys_setloginclass(Thread *thread, ptr<char> namebuf);
-SysResult sys_rctl_get_racct(Thread *thread, ptr<const void> inbufp, size_t inbuflen, ptr<void> outbuf, size_t outbuflen);
-SysResult sys_rctl_get_rules(Thread *thread, ptr<const void> inbufp, size_t inbuflen, ptr<void> outbuf, size_t outbuflen);
-SysResult sys_rctl_get_limits(Thread *thread, ptr<const void> inbufp, size_t inbuflen, ptr<void> outbuf, size_t outbuflen);
-SysResult sys_rctl_add_rule(Thread *thread, ptr<const void> inbufp, size_t inbuflen, ptr<void> outbuf, size_t outbuflen);
-SysResult sys_rctl_remove_rule(Thread *thread, ptr<const void> inbufp, size_t inbuflen, ptr<void> outbuf, size_t outbuflen);
+SysResult sys_rctl_get_racct(Thread *thread, ptr<const void> inbufp,
+                             size_t inbuflen, ptr<void> outbuf,
+                             size_t outbuflen);
+SysResult sys_rctl_get_rules(Thread *thread, ptr<const void> inbufp,
+                             size_t inbuflen, ptr<void> outbuf,
+                             size_t outbuflen);
+SysResult sys_rctl_get_limits(Thread *thread, ptr<const void> inbufp,
+                              size_t inbuflen, ptr<void> outbuf,
+                              size_t outbuflen);
+SysResult sys_rctl_add_rule(Thread *thread, ptr<const void> inbufp,
+                            size_t inbuflen, ptr<void> outbuf,
+                            size_t outbuflen);
+SysResult sys_rctl_remove_rule(Thread *thread, ptr<const void> inbufp,
+                               size_t inbuflen, ptr<void> outbuf,
+                               size_t outbuflen);
 SysResult sys_posix_fallocate(Thread *thread, sint fd, off_t offset, off_t len);
-SysResult sys_posix_fadvise(Thread *thread, sint fd, off_t offset, off_t len, sint advice);
+SysResult sys_posix_fadvise(Thread *thread, sint fd, off_t offset, off_t len,
+                            sint advice);
 
-SysResult sys_netcontrol(Thread *thread, sint fd, uint op, ptr<void> buf, uint nbuf);
+SysResult sys_netcontrol(Thread *thread, sint fd, uint op, ptr<void> buf,
+                         uint nbuf);
 SysResult sys_netabort(Thread *thread /* TODO */);
 SysResult sys_netgetsockinfo(Thread *thread /* TODO */);
-SysResult sys_socketex(Thread *thread, ptr<const char> name, sint domain, sint type, sint protocol);
+SysResult sys_socketex(Thread *thread, ptr<const char> name, sint domain,
+                       sint type, sint protocol);
 SysResult sys_socketclose(Thread *thread /* TODO */);
 SysResult sys_netgetiflist(Thread *thread /* TODO */);
 SysResult sys_kqueueex(Thread *thread /* TODO */);
 SysResult sys_mtypeprotect(Thread *thread /* TODO */);
-SysResult sys_regmgr_call(Thread *thread, uint32_t op, uint32_t id, ptr<void> result, ptr<void> value, uint64_t type);
+SysResult sys_regmgr_call(Thread *thread, uint32_t op, uint32_t id,
+                          ptr<void> result, ptr<void> value, uint64_t type);
 SysResult sys_jitshm_create(Thread *thread /* TODO */);
 SysResult sys_jitshm_alias(Thread *thread /* TODO */);
 SysResult sys_dl_get_list(Thread *thread /* TODO */);
 SysResult sys_dl_get_info(Thread *thread /* TODO */);
 SysResult sys_dl_notify_event(Thread *thread /* TODO */);
-SysResult sys_evf_create(Thread *thread, ptr<char> name, sint attrs, ptr<struct evFlag> evf);
+SysResult sys_evf_create(Thread *thread, ptr<char> name, sint attrs,
+                         ptr<struct evFlag> evf);
 SysResult sys_evf_delete(Thread *thread, sint id);
 SysResult sys_evf_open(Thread *thread, ptr<char> name);
 SysResult sys_evf_close(Thread *thread, sint id);
-SysResult sys_evf_wait(Thread *thread, sint id, uint64_t patternSet, uint64_t mode, ptr<uint64_t> pPatternSet, ptr<uint> pTimeout);
-SysResult sys_evf_trywait(Thread *thread, sint id, uint64_t patternSet, uint64_t mode, ptr<uint64_t> pPatternSet); // FIXME: verify args
+SysResult sys_evf_wait(Thread *thread, sint id, uint64_t patternSet,
+                       uint64_t mode, ptr<uint64_t> pPatternSet,
+                       ptr<uint> pTimeout);
+SysResult sys_evf_trywait(Thread *thread, sint id, uint64_t patternSet,
+                          uint64_t mode,
+                          ptr<uint64_t> pPatternSet); // FIXME: verify args
 SysResult sys_evf_set(Thread *thread, sint id, uint64_t value);
 SysResult sys_evf_clear(Thread *thread, sint id, uint64_t value);
-SysResult sys_evf_cancel(Thread *thread, sint id, uint64_t value, ptr<sint> pNumWaitThreads);
+SysResult sys_evf_cancel(Thread *thread, sint id, uint64_t value,
+                         ptr<sint> pNumWaitThreads);
 SysResult sys_query_memory_protection(Thread *thread /* TODO */);
 SysResult sys_batch_map(Thread *thread /* TODO */);
 SysResult sys_osem_create(Thread *thread /* TODO */);
@@ -428,7 +640,8 @@ SysResult sys_osem_wait(Thread *thread /* TODO */);
 SysResult sys_osem_trywait(Thread *thread /* TODO */);
 SysResult sys_osem_post(Thread *thread /* TODO */);
 SysResult sys_osem_cancel(Thread *thread /* TODO */);
-SysResult sys_namedobj_create(Thread *thread, ptr<const char> name, ptr<void> object, uint64_t type);
+SysResult sys_namedobj_create(Thread *thread, ptr<const char> name,
+                              ptr<void> object, uint64_t type);
 SysResult sys_namedobj_delete(Thread *thread /* TODO */);
 SysResult sys_set_vm_container(Thread *thread /* TODO */);
 SysResult sys_debug_init(Thread *thread /* TODO */);
@@ -443,7 +656,8 @@ SysResult sys_budget_create(Thread *thread /* TODO */);
 SysResult sys_budget_delete(Thread *thread /* TODO */);
 SysResult sys_budget_get(Thread *thread /* TODO */);
 SysResult sys_budget_set(Thread *thread /* TODO */);
-SysResult sys_virtual_query(Thread *thread, ptr<void> addr, uint64_t unk, ptr<void> info, size_t infosz);
+SysResult sys_virtual_query(Thread *thread, ptr<void> addr, uint64_t unk,
+                            ptr<void> info, size_t infosz);
 SysResult sys_mdbg_call(Thread *thread /* TODO */);
 SysResult sys_obs_sblock_create(Thread *thread /* TODO */);
 SysResult sys_obs_sblock_delete(Thread *thread /* TODO */);
@@ -459,27 +673,38 @@ SysResult sys_obs_eport_close(Thread *thread /* TODO */);
 SysResult sys_is_in_sandbox(Thread *thread /* TODO */);
 SysResult sys_dmem_container(Thread *thread);
 SysResult sys_get_authinfo(Thread *thread, pid_t pid, ptr<void> info);
-SysResult sys_mname(Thread *thread, ptr<void> address, uint64_t length, ptr<const char> name);
+SysResult sys_mname(Thread *thread, ptr<void> address, uint64_t length,
+                    ptr<const char> name);
 SysResult sys_dynlib_dlopen(Thread *thread /* TODO */);
 SysResult sys_dynlib_dlclose(Thread *thread /* TODO */);
-SysResult sys_dynlib_dlsym(Thread *thread, SceKernelModule handle, ptr<const char> symbol, ptr<ptr<void>> addrp);
-SysResult sys_dynlib_get_list(Thread *thread, ptr<SceKernelModule> pArray, size_t numArray, ptr<size_t> pActualNum);
-SysResult sys_dynlib_get_info(Thread *thread, SceKernelModule handle, ptr<ModuleInfo> pInfo);
-SysResult sys_dynlib_load_prx(Thread *thread, ptr<const char> name, uint64_t arg1, ptr<ModuleHandle> pHandle, uint64_t arg3);
-SysResult sys_dynlib_unload_prx(Thread *thread, SceKernelModule handle /* TODO*/);
+SysResult sys_dynlib_dlsym(Thread *thread, SceKernelModule handle,
+                           ptr<const char> symbol, ptr<ptr<void>> addrp);
+SysResult sys_dynlib_get_list(Thread *thread, ptr<SceKernelModule> pArray,
+                              size_t numArray, ptr<size_t> pActualNum);
+SysResult sys_dynlib_get_info(Thread *thread, SceKernelModule handle,
+                              ptr<ModuleInfo> pInfo);
+SysResult sys_dynlib_load_prx(Thread *thread, ptr<const char> name,
+                              uint64_t arg1, ptr<ModuleHandle> pHandle,
+                              uint64_t arg3);
+SysResult sys_dynlib_unload_prx(Thread *thread,
+                                SceKernelModule handle /* TODO*/);
 SysResult sys_dynlib_do_copy_relocations(Thread *thread);
 SysResult sys_dynlib_prepare_dlclose(Thread *thread /* TODO */);
-SysResult sys_dynlib_get_proc_param(Thread *thread, ptr<ptr<void>> procParam, ptr<uint64_t> procParamSize);
+SysResult sys_dynlib_get_proc_param(Thread *thread, ptr<ptr<void>> procParam,
+                                    ptr<uint64_t> procParamSize);
 SysResult sys_dynlib_process_needed_and_relocate(Thread *thread);
 SysResult sys_sandbox_path(Thread *thread /* TODO */);
-SysResult sys_mdbg_service(Thread *thread, uint32_t op, ptr<void> arg0, ptr<void> arg1);
+SysResult sys_mdbg_service(Thread *thread, uint32_t op, ptr<void> arg0,
+                           ptr<void> arg1);
 SysResult sys_randomized_path(Thread *thread /* TODO */);
 SysResult sys_rdup(Thread *thread /* TODO */);
 SysResult sys_dl_get_metadata(Thread *thread /* TODO */);
 SysResult sys_workaround8849(Thread *thread /* TODO */);
 SysResult sys_is_development_mode(Thread *thread /* TODO */);
 SysResult sys_get_self_auth_info(Thread *thread /* TODO */);
-SysResult sys_dynlib_get_info_ex(Thread *thread, SceKernelModule handle, ptr<struct Unk> unk, ptr<ModuleInfoEx> destModuleInfoEx);
+SysResult sys_dynlib_get_info_ex(Thread *thread, SceKernelModule handle,
+                                 ptr<struct Unk> unk,
+                                 ptr<ModuleInfoEx> destModuleInfoEx);
 SysResult sys_budget_getid(Thread *thread);
 SysResult sys_budget_get_ptype(Thread *thread, sint budgetId);
 SysResult sys_get_paging_stats_of_all_threads(Thread *thread /* TODO */);
@@ -493,7 +718,9 @@ SysResult sys_get_paging_stats_of_all_objects(Thread *thread /* TODO */);
 SysResult sys_test_debug_rwmem(Thread *thread /* TODO */);
 SysResult sys_free_stack(Thread *thread /* TODO */);
 SysResult sys_suspend_system(Thread *thread /* TODO */);
-SysResult sys_ipmimgr_call(Thread *thread, uint64_t id, uint64_t arg2, ptr<uint64_t> result, ptr<uint64_t> params, uint64_t arg5, uint64_t arg6);
+SysResult sys_ipmimgr_call(Thread *thread, uint64_t id, uint64_t arg2,
+                           ptr<uint64_t> result, ptr<uint64_t> params,
+                           uint64_t arg5, uint64_t arg6);
 SysResult sys_get_gpo(Thread *thread /* TODO */);
 SysResult sys_get_vm_map_timestamp(Thread *thread /* TODO */);
 SysResult sys_opmc_set_hw(Thread *thread /* TODO */);
@@ -520,7 +747,8 @@ SysResult sys_extend_page_table_pool2(Thread *thread);
 SysResult sys_get_kernel_mem_statistics(Thread *thread /* TODO */);
 SysResult sys_get_sdk_compiled_version(Thread *thread /* TODO */);
 SysResult sys_app_state_change(Thread *thread /* TODO */);
-SysResult sys_dynlib_get_obj_member(Thread *thread, SceKernelModule handle, uint64_t index, ptr<ptr<void>> addrp);
+SysResult sys_dynlib_get_obj_member(Thread *thread, SceKernelModule handle,
+                                    uint64_t index, ptr<ptr<void>> addrp);
 SysResult sys_budget_get_ptype_of_budget(Thread *thread /* TODO */);
 SysResult sys_prepare_to_resume_process(Thread *thread /* TODO */);
 SysResult sys_process_terminate(Thread *thread /* TODO */);
diff --git a/orbis-kernel/include/orbis/thread.hpp b/orbis-kernel/include/orbis/thread.hpp
index f67cf8e71..8778f7c2e 100644
--- a/orbis-kernel/include/orbis/thread.hpp
+++ b/orbis-kernel/include/orbis/thread.hpp
@@ -1,10 +1,10 @@
 #pragma once
 
-#include "thread/cpuset.hpp" // IWYU pragma: export
-#include "thread/Process.hpp" // IWYU pragma: export
-#include "thread/ProcessOps.hpp" // IWYU pragma: export
+#include "thread/Process.hpp"      // IWYU pragma: export
+#include "thread/ProcessOps.hpp"   // IWYU pragma: export
 #include "thread/ProcessState.hpp" // IWYU pragma: export
-#include "thread/sysent.hpp" // IWYU pragma: export
-#include "thread/Thread.hpp" // IWYU pragma: export
-#include "thread/ThreadState.hpp" // IWYU pragma: export
-#include "thread/types.hpp" // IWYU pragma: export
+#include "thread/Thread.hpp"       // IWYU pragma: export
+#include "thread/ThreadState.hpp"  // IWYU pragma: export
+#include "thread/cpuset.hpp"       // IWYU pragma: export
+#include "thread/sysent.hpp"       // IWYU pragma: export
+#include "thread/types.hpp"        // IWYU pragma: export
diff --git a/orbis-kernel/include/orbis/thread/ProcessOps.hpp b/orbis-kernel/include/orbis/thread/ProcessOps.hpp
index 161f74abd..dee7cd513 100644
--- a/orbis-kernel/include/orbis/thread/ProcessOps.hpp
+++ b/orbis-kernel/include/orbis/thread/ProcessOps.hpp
@@ -1,45 +1,58 @@
 #pragma once
 #include "../error/SysResult.hpp"
 #include "../module/ModuleHandle.hpp"
-#include "orbis-config.hpp"
 #include "../thread/types.hpp"
+#include "orbis-config.hpp"
 
 namespace orbis {
 struct Thread;
 struct Module;
 
 struct ProcessOps {
-  SysResult (*mmap)(Thread *thread, caddr_t addr, size_t len, sint prot, sint flags, sint fd, off_t pos);
+  SysResult (*mmap)(Thread *thread, caddr_t addr, size_t len, sint prot,
+                    sint flags, sint fd, off_t pos);
   SysResult (*munmap)(Thread *thread, ptr<void> addr, size_t len);
   SysResult (*msync)(Thread *thread, ptr<void> addr, size_t len, sint flags);
-  SysResult (*mprotect)(Thread *thread, ptr<const void> addr, size_t len, sint prot);
-  SysResult (*minherit)(Thread *thread, ptr<void> addr, size_t len, sint inherit);
+  SysResult (*mprotect)(Thread *thread, ptr<const void> addr, size_t len,
+                        sint prot);
+  SysResult (*minherit)(Thread *thread, ptr<void> addr, size_t len,
+                        sint inherit);
   SysResult (*madvise)(Thread *thread, ptr<void> addr, size_t len, sint behav);
-  SysResult (*mincore)(Thread *thread, ptr<const void> addr, size_t len, ptr<char> vec);
+  SysResult (*mincore)(Thread *thread, ptr<const void> addr, size_t len,
+                       ptr<char> vec);
   SysResult (*mlock)(Thread *thread, ptr<const void> addr, size_t len);
   SysResult (*mlockall)(Thread *thread, sint how);
   SysResult (*munlockall)(Thread *thread);
   SysResult (*munlock)(Thread *thread, ptr<const void> addr, size_t len);
-  SysResult (*virtual_query)(Thread *thread, ptr<const void> addr, sint flags, ptr<void> info, ulong infoSize);
+  SysResult (*virtual_query)(Thread *thread, ptr<const void> addr, sint flags,
+                             ptr<void> info, ulong infoSize);
 
-  SysResult (*open)(Thread *thread, ptr<const char> path, sint flags, sint mode);
+  SysResult (*open)(Thread *thread, ptr<const char> path, sint flags,
+                    sint mode);
   SysResult (*close)(Thread *thread, sint fd);
   SysResult (*ioctl)(Thread *thread, sint fd, ulong com, caddr_t argp);
   SysResult (*write)(Thread *thread, sint fd, ptr<const void> data, ulong size);
   SysResult (*read)(Thread *thread, sint fd, ptr<void> data, ulong size);
-  SysResult (*pread)(Thread *thread, sint fd, ptr<void> data, ulong size, ulong offset);
-  SysResult (*pwrite)(Thread *thread, sint fd, ptr<const void> data, ulong size, ulong offset);
+  SysResult (*pread)(Thread *thread, sint fd, ptr<void> data, ulong size,
+                     ulong offset);
+  SysResult (*pwrite)(Thread *thread, sint fd, ptr<const void> data, ulong size,
+                      ulong offset);
   SysResult (*lseek)(Thread *thread, sint fd, ulong offset, sint whence);
   SysResult (*ftruncate)(Thread *thread, sint fd, off_t length);
   SysResult (*truncate)(Thread *thread, ptr<const char> path, off_t length);
 
-  SysResult (*dynlib_get_obj_member)(Thread *thread, ModuleHandle handle, uint64_t index, ptr<ptr<void>> addrp);
-  SysResult (*dynlib_dlsym)(Thread *thread, ModuleHandle handle, ptr<const char> symbol, ptr<ptr<void>> addrp);
+  SysResult (*dynlib_get_obj_member)(Thread *thread, ModuleHandle handle,
+                                     uint64_t index, ptr<ptr<void>> addrp);
+  SysResult (*dynlib_dlsym)(Thread *thread, ModuleHandle handle,
+                            ptr<const char> symbol, ptr<ptr<void>> addrp);
   SysResult (*dynlib_do_copy_relocations)(Thread *thread);
-  SysResult (*dynlib_load_prx)(Thread *thread, ptr<const char> name, uint64_t arg1, ptr<ModuleHandle> pHandle, uint64_t arg3);
+  SysResult (*dynlib_load_prx)(Thread *thread, ptr<const char> name,
+                               uint64_t arg1, ptr<ModuleHandle> pHandle,
+                               uint64_t arg3);
   SysResult (*dynlib_unload_prx)(Thread *thread, ModuleHandle handle);
 
-  SysResult (*thr_create)(Thread *thread, ptr<struct ucontext> ctxt, ptr<slong> arg, sint flags);
+  SysResult (*thr_create)(Thread *thread, ptr<struct ucontext> ctxt,
+                          ptr<slong> arg, sint flags);
   SysResult (*thr_new)(Thread *thread, ptr<thr_param> param, sint param_size);
   SysResult (*thr_exit)(Thread *thread, ptr<slong> state);
   SysResult (*thr_kill)(Thread *thread, slong id, sint sig);
diff --git a/orbis-kernel/include/orbis/thread/Thread.hpp b/orbis-kernel/include/orbis/thread/Thread.hpp
index 5dce313c5..a1f79c410 100644
--- a/orbis-kernel/include/orbis/thread/Thread.hpp
+++ b/orbis-kernel/include/orbis/thread/Thread.hpp
@@ -1,8 +1,8 @@
 #pragma once
 
+#include "ThreadState.hpp"
 #include "orbis-config.hpp"
 #include "types.hpp"
-#include "ThreadState.hpp"
 
 #include "../utils/SharedMutex.hpp"
 
@@ -19,10 +19,7 @@ struct Thread {
   uint64_t gsBase{};
   char name[32];
 
-  uint64_t sigMask[4] = {
-    0x7fff'ffff,
-    0
-  };
+  uint64_t sigMask[4] = {0x7fff'ffff, 0};
 
   lwpid_t tid = -1;
   ThreadState state = ThreadState::INACTIVE;
diff --git a/orbis-kernel/include/orbis/thread/ThreadState.hpp b/orbis-kernel/include/orbis/thread/ThreadState.hpp
index 7c898205d..c2dd92421 100644
--- a/orbis-kernel/include/orbis/thread/ThreadState.hpp
+++ b/orbis-kernel/include/orbis/thread/ThreadState.hpp
@@ -3,5 +3,11 @@
 #include <cstdint>
 
 namespace orbis {
-enum class ThreadState : std::uint32_t { INACTIVE, INHIBITED, CAN_RUN, RUNQ, RUNNING };
+enum class ThreadState : std::uint32_t {
+  INACTIVE,
+  INHIBITED,
+  CAN_RUN,
+  RUNQ,
+  RUNNING
+};
 } // namespace orbis
diff --git a/orbis-kernel/include/orbis/thread/types.hpp b/orbis-kernel/include/orbis/thread/types.hpp
index 66cd6413e..33f576eb3 100644
--- a/orbis-kernel/include/orbis/thread/types.hpp
+++ b/orbis-kernel/include/orbis/thread/types.hpp
@@ -13,15 +13,19 @@ struct rtprio {
 };
 
 struct thr_param {
-	ptr<void(void *)> start_func;
-	ptr<void> arg;
-	ptr<char> stack_base;
-	size_t stack_size;
-	ptr<char> tls_base;
-	size_t tls_size;
-	ptr<slong> child_tid; // Address to store the new thread identifier, for the child's use
-	ptr<slong> parent_tid; // Address to store the new thread identifier, for the parent's use
-	sint flags; // Thread	creation flags. The flags member may specify the following flags:
-	ptr<rtprio> rtp; // Real-time scheduling priority for the new thread. May be NULL to inherit the priority from the creating	thread
+  ptr<void(void *)> start_func;
+  ptr<void> arg;
+  ptr<char> stack_base;
+  size_t stack_size;
+  ptr<char> tls_base;
+  size_t tls_size;
+  ptr<slong> child_tid;  // Address to store the new thread identifier, for the
+                         // child's use
+  ptr<slong> parent_tid; // Address to store the new thread identifier, for the
+                         // parent's use
+  sint flags;      // Thread	creation flags. The flags member may specify the
+                   // following flags:
+  ptr<rtprio> rtp; // Real-time scheduling priority for the new thread. May be
+                   // NULL to inherit the priority from the creating	thread
 };
 } // namespace orbis
diff --git a/orbis-kernel/include/orbis/utils/AtomicOp.hpp b/orbis-kernel/include/orbis/utils/AtomicOp.hpp
index adac73450..be6c7849a 100644
--- a/orbis-kernel/include/orbis/utils/AtomicOp.hpp
+++ b/orbis-kernel/include/orbis/utils/AtomicOp.hpp
@@ -1,8 +1,8 @@
 #pragma once
 
 #include <atomic>
-#include <utility>
 #include <functional>
+#include <utility>
 
 namespace orbis {
 inline namespace utils {
diff --git a/orbis-kernel/include/orbis/utils/IdMap.hpp b/orbis-kernel/include/orbis/utils/IdMap.hpp
index d4127d9de..10856e436 100644
--- a/orbis-kernel/include/orbis/utils/IdMap.hpp
+++ b/orbis-kernel/include/orbis/utils/IdMap.hpp
@@ -13,8 +13,7 @@ namespace orbis {
 inline namespace utils {
 template <WithRc T, typename IdT = int, std::size_t MaxId = 4096,
           std::size_t MinId = 0>
-  requires(MaxId > MinId)
-class RcIdMap {
+requires(MaxId > MinId) class RcIdMap {
   static constexpr auto ChunkSize = std::min<std::size_t>(MaxId - MinId, 64);
   static constexpr auto ChunkCount =
       (MaxId - MinId + ChunkSize - 1) / ChunkSize;
@@ -191,8 +190,7 @@ public:
 
 template <typename T, typename IdT = int, std::size_t MaxId = 4096,
           std::size_t MinId = 0>
-  requires(MaxId > MinId)
-struct OwningIdMap {
+requires(MaxId > MinId) struct OwningIdMap {
   static constexpr auto ChunkSize = std::min<std::size_t>(MaxId - MinId, 64);
   static constexpr auto ChunkCount =
       (MaxId - MinId + ChunkSize - 1) / ChunkSize;
@@ -250,8 +248,8 @@ struct OwningIdMap {
   BitSet<ChunkCount> fullChunks;
 
   template <typename... ArgsT>
-    requires(std::is_constructible_v<T, ArgsT...>)
-  std::pair<IdT, T *> emplace(ArgsT &&...args) {
+  requires(std::is_constructible_v<T, ArgsT...>) std::pair<IdT, T *> emplace(
+      ArgsT &&...args) {
     auto page = fullChunks.countr_one();
 
     if (page == ChunkCount) {
diff --git a/orbis-kernel/include/orbis/utils/Rc.hpp b/orbis-kernel/include/orbis/utils/Rc.hpp
index 7f8cc7eb0..271b2b503 100644
--- a/orbis-kernel/include/orbis/utils/Rc.hpp
+++ b/orbis-kernel/include/orbis/utils/Rc.hpp
@@ -6,9 +6,9 @@
 #include <utility>
 
 namespace orbis {
-//template <typename T, typename... Args> T *knew(Args &&...args);
+// template <typename T, typename... Args> T *knew(Args &&...args);
 inline namespace utils {
-void kfree(void* ptr, std::size_t size);
+void kfree(void *ptr, std::size_t size);
 
 struct RcBase {
   std::atomic<unsigned> references{0};
@@ -50,24 +50,23 @@ public:
   Ref() = default;
 
   template <typename OT>
-    requires(std::is_base_of_v<T, OT>)
-  Ref(OT *ref) : m_ref(ref) {
+  requires(std::is_base_of_v<T, OT>) Ref(OT *ref) : m_ref(ref) {
     if (m_ref != nullptr) {
       ref->incRef();
     }
   }
 
   template <typename OT>
-    requires(std::is_base_of_v<T, OT>)
-  Ref(const Ref<OT> &other) : m_ref(other.get()) {
+  requires(std::is_base_of_v<T, OT>) Ref(const Ref<OT> &other)
+      : m_ref(other.get()) {
     if (m_ref != nullptr) {
       m_ref->incRef();
     }
   }
 
   template <typename OT>
-    requires(std::is_base_of_v<T, OT>)
-  Ref(Ref<OT> &&other) : m_ref(other.release()) {}
+  requires(std::is_base_of_v<T, OT>) Ref(Ref<OT> &&other)
+      : m_ref(other.release()) {}
 
   Ref(const Ref &other) : m_ref(other.get()) {
     if (m_ref != nullptr) {
@@ -77,22 +76,19 @@ public:
   Ref(Ref &&other) : m_ref(other.release()) {}
 
   template <typename OT>
-    requires(std::is_base_of_v<T, OT>)
-  Ref &operator=(Ref<OT> &&other) {
+  requires(std::is_base_of_v<T, OT>) Ref &operator=(Ref<OT> &&other) {
     other.swap(*this);
     return *this;
   }
 
   template <typename OT>
-    requires(std::is_base_of_v<T, OT>)
-  Ref &operator=(OT *other) {
+  requires(std::is_base_of_v<T, OT>) Ref &operator=(OT *other) {
     *this = Ref(other);
     return *this;
   }
 
   template <typename OT>
-    requires(std::is_base_of_v<T, OT>)
-  Ref &operator=(const Ref<OT> &other) {
+  requires(std::is_base_of_v<T, OT>) Ref &operator=(const Ref<OT> &other) {
     *this = Ref(other);
     return *this;
   }
diff --git a/orbis-kernel/src/evf.cpp b/orbis-kernel/src/evf.cpp
index faa179664..d9fd756e5 100644
--- a/orbis-kernel/src/evf.cpp
+++ b/orbis-kernel/src/evf.cpp
@@ -81,8 +81,7 @@ orbis::ErrorCode orbis::EventFlag::wait(Thread *thread, std::uint8_t waitMode,
   return {};
 }
 
-orbis::ErrorCode orbis::EventFlag::tryWait(Thread *,
-                                           std::uint8_t waitMode,
+orbis::ErrorCode orbis::EventFlag::tryWait(Thread *, std::uint8_t waitMode,
                                            std::uint64_t bitPattern,
                                            std::uint64_t *patternSet) {
   writer_lock lock(queueMtx);
@@ -91,9 +90,8 @@ orbis::ErrorCode orbis::EventFlag::tryWait(Thread *,
     return ErrorCode::ACCES;
   }
 
-  auto waitingThread = WaitingThread{
-                                      .bitPattern = bitPattern,
-                                      .waitMode = waitMode};
+  auto waitingThread =
+      WaitingThread{.bitPattern = bitPattern, .waitMode = waitMode};
 
   if (auto patValue = value.load(std::memory_order::relaxed);
       waitingThread.test(patValue)) {
@@ -138,7 +136,9 @@ std::size_t orbis::EventFlag::notify(NotifyType type, std::uint64_t bits) {
     thread->mtx->unlock(); // release wait on waiter thread
 
     waitingThreadsCount.fetch_sub(1, std::memory_order::relaxed);
-    std::memmove(thread, thread + 1, (waitingThreads + count - (thread + 1)) * sizeof(*waitingThreads));
+    std::memmove(thread, thread + 1,
+                 (waitingThreads + count - (thread + 1)) *
+                     sizeof(*waitingThreads));
     --count;
     return true;
   };
diff --git a/orbis-kernel/src/module.cpp b/orbis-kernel/src/module.cpp
index 2aef3a382..26839c843 100644
--- a/orbis-kernel/src/module.cpp
+++ b/orbis-kernel/src/module.cpp
@@ -131,8 +131,10 @@ static orbis::SysResult doRelocation(orbis::Process *process,
       }
     }
 
-    std::printf("'%s' ('%s') uses undefined symbol '%llx' in '%s' ('%s') module\n",
-                module->moduleName, module->soName, (unsigned long long)symbol.id, defModule->moduleName, defModule->soName);
+    std::printf(
+        "'%s' ('%s') uses undefined symbol '%llx' in '%s' ('%s') module\n",
+        module->moduleName, module->soName, (unsigned long long)symbol.id,
+        defModule->moduleName, defModule->soName);
     if (foundInLibs.size() > 0) {
       std::printf("Requested library is '%s', exists in libraries: [",
                   library.name.c_str());
diff --git a/orbis-kernel/src/sys/sys_acct.cpp b/orbis-kernel/src/sys/sys_acct.cpp
index 910225179..32edda6c0 100644
--- a/orbis-kernel/src/sys/sys_acct.cpp
+++ b/orbis-kernel/src/sys/sys_acct.cpp
@@ -1,4 +1,6 @@
-#include "sys/sysproto.hpp"
 #include "error.hpp"
+#include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_acct(Thread *thread, ptr<char> path) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_acct(Thread *thread, ptr<char> path) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_audit.cpp b/orbis-kernel/src/sys/sys_audit.cpp
index d13154168..4a9dd33a2 100644
--- a/orbis-kernel/src/sys/sys_audit.cpp
+++ b/orbis-kernel/src/sys/sys_audit.cpp
@@ -1,11 +1,35 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_audit(Thread *thread, ptr<const void> record, uint length) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_auditon(Thread *thread, sint cmd, ptr<void> data, uint length) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_getauid(Thread *thread, ptr<uid_t> auid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_setauid(Thread *thread, ptr<uid_t> auid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_getaudit(Thread *thread, ptr<struct auditinfo> auditinfo) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_setaudit(Thread *thread, ptr<struct auditinfo> auditinfo) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_getaudit_addr(Thread *thread, ptr<struct auditinfo_addr> auditinfo_addr, uint length) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_setaudit_addr(Thread *thread, ptr<struct auditinfo_addr> auditinfo_addr, uint length) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_auditctl(Thread *thread, ptr<char> path) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_audit(Thread *thread, ptr<const void> record,
+                                  uint length) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_auditon(Thread *thread, sint cmd, ptr<void> data,
+                                    uint length) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_getauid(Thread *thread, ptr<uid_t> auid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_setauid(Thread *thread, ptr<uid_t> auid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_getaudit(Thread *thread,
+                                     ptr<struct auditinfo> auditinfo) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_setaudit(Thread *thread,
+                                     ptr<struct auditinfo> auditinfo) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_getaudit_addr(
+    Thread *thread, ptr<struct auditinfo_addr> auditinfo_addr, uint length) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_setaudit_addr(
+    Thread *thread, ptr<struct auditinfo_addr> auditinfo_addr, uint length) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_auditctl(Thread *thread, ptr<char> path) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_capability.cpp b/orbis-kernel/src/sys/sys_capability.cpp
index 3a66c7170..6f33f57bf 100644
--- a/orbis-kernel/src/sys/sys_capability.cpp
+++ b/orbis-kernel/src/sys/sys_capability.cpp
@@ -1,6 +1,15 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_cap_enter(Thread *thread) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_cap_getmode(Thread *thread, ptr<uint> modep) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_cap_new(Thread *thread, sint fd, uint64_t rights) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_cap_getrights(Thread *thread, sint fd, ptr<uint64_t> rights) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_cap_enter(Thread *thread) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_cap_getmode(Thread *thread, ptr<uint> modep) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_cap_new(Thread *thread, sint fd, uint64_t rights) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_cap_getrights(Thread *thread, sint fd,
+                                          ptr<uint64_t> rights) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_context.cpp b/orbis-kernel/src/sys/sys_context.cpp
index c0c6713a6..dd16c861c 100644
--- a/orbis-kernel/src/sys/sys_context.cpp
+++ b/orbis-kernel/src/sys/sys_context.cpp
@@ -1,5 +1,15 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_getcontext(Thread *thread, ptr<struct ucontext> ucp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_setcontext(Thread *thread, ptr<struct ucontext> ucp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_swapcontext(Thread *thread, ptr<struct ucontext> oucp, ptr<struct ucontext> ucp) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_getcontext(Thread *thread,
+                                       ptr<struct ucontext> ucp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_setcontext(Thread *thread,
+                                       ptr<struct ucontext> ucp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_swapcontext(Thread *thread,
+                                        ptr<struct ucontext> oucp,
+                                        ptr<struct ucontext> ucp) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_cpuset.cpp b/orbis-kernel/src/sys/sys_cpuset.cpp
index e56fb1217..d1af36225 100644
--- a/orbis-kernel/src/sys/sys_cpuset.cpp
+++ b/orbis-kernel/src/sys/sys_cpuset.cpp
@@ -1,7 +1,26 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_cpuset(Thread *thread, ptr<cpusetid_t> setid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_cpuset_setid(Thread *thread, cpuwhich_t which, id_t id, cpusetid_t setid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_cpuset_getid(Thread *thread, cpulevel_t level, cpuwhich_t which, id_t id, ptr<cpusetid_t> setid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_cpuset_getaffinity(Thread *thread, cpulevel_t level, cpuwhich_t which, id_t id, size_t cpusetsize, ptr<cpuset> mask) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_cpuset_setaffinity(Thread *thread, cpulevel_t level, cpuwhich_t which, id_t id, size_t cpusetsize, ptr<const cpuset> mask) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_cpuset(Thread *thread, ptr<cpusetid_t> setid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_cpuset_setid(Thread *thread, cpuwhich_t which,
+                                         id_t id, cpusetid_t setid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_cpuset_getid(Thread *thread, cpulevel_t level,
+                                         cpuwhich_t which, id_t id,
+                                         ptr<cpusetid_t> setid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_cpuset_getaffinity(Thread *thread, cpulevel_t level,
+                                               cpuwhich_t which, id_t id,
+                                               size_t cpusetsize,
+                                               ptr<cpuset> mask) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_cpuset_setaffinity(Thread *thread, cpulevel_t level,
+                                               cpuwhich_t which, id_t id,
+                                               size_t cpusetsize,
+                                               ptr<const cpuset> mask) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_descrip.cpp b/orbis-kernel/src/sys/sys_descrip.cpp
index 109ccac18..c370b6eb7 100644
--- a/orbis-kernel/src/sys/sys_descrip.cpp
+++ b/orbis-kernel/src/sys/sys_descrip.cpp
@@ -1,9 +1,18 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_getdtablesize(Thread *thread) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_dup2(Thread *thread, uint from, uint to) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_dup(Thread *thread, uint fd) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_fcntl(Thread *thread, sint fd, sint cmd, slong arg) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_getdtablesize(Thread *thread) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_dup2(Thread *thread, uint from, uint to) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_dup(Thread *thread, uint fd) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_fcntl(Thread *thread, sint fd, sint cmd,
+                                  slong arg) {
+  return ErrorCode::NOSYS;
+}
 orbis::SysResult orbis::sys_close(Thread *thread, sint fd) {
   if (auto close = thread->tproc->ops->close) {
     return close(thread, fd);
@@ -11,8 +20,20 @@ orbis::SysResult orbis::sys_close(Thread *thread, sint fd) {
 
   return ErrorCode::NOSYS;
 }
-orbis::SysResult orbis::sys_closefrom(Thread *thread, sint lowfd) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_fstat(Thread *thread, sint fd, ptr<struct stat> ub) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_nfstat(Thread *thread, sint fd, ptr<struct nstat> sb) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_fpathconf(Thread *thread, sint fd, sint name) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_flock(Thread *thread, sint fd, sint how) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_closefrom(Thread *thread, sint lowfd) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_fstat(Thread *thread, sint fd,
+                                  ptr<struct stat> ub) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_nfstat(Thread *thread, sint fd,
+                                   ptr<struct nstat> sb) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_fpathconf(Thread *thread, sint fd, sint name) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_flock(Thread *thread, sint fd, sint how) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_environment.cpp b/orbis-kernel/src/sys/sys_environment.cpp
index 8e5558e63..8b394e2aa 100644
--- a/orbis-kernel/src/sys/sys_environment.cpp
+++ b/orbis-kernel/src/sys/sys_environment.cpp
@@ -1,3 +1,7 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_kenv(Thread *thread, sint what, ptr<const char> name, ptr<char> value, sint len) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_kenv(Thread *thread, sint what,
+                                 ptr<const char> name, ptr<char> value,
+                                 sint len) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_event.cpp b/orbis-kernel/src/sys/sys_event.cpp
index 90537c737..a2fb79252 100644
--- a/orbis-kernel/src/sys/sys_event.cpp
+++ b/orbis-kernel/src/sys/sys_event.cpp
@@ -1,9 +1,10 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_kqueue(Thread *thread) {
-  return {};
-}
+orbis::SysResult orbis::sys_kqueue(Thread *thread) { return {}; }
 
-orbis::SysResult orbis::sys_kevent(Thread *thread, sint fd, ptr<struct kevent> changelist, sint nchanges, ptr<struct kevent> eventlist, sint nevents, ptr<const struct timespec> timeout) {
+orbis::SysResult orbis::sys_kevent(Thread *thread, sint fd,
+                                   ptr<struct kevent> changelist, sint nchanges,
+                                   ptr<struct kevent> eventlist, sint nevents,
+                                   ptr<const struct timespec> timeout) {
   return {};
 }
diff --git a/orbis-kernel/src/sys/sys_exec.cpp b/orbis-kernel/src/sys/sys_exec.cpp
index 8fde41912..29f9ca43a 100644
--- a/orbis-kernel/src/sys/sys_exec.cpp
+++ b/orbis-kernel/src/sys/sys_exec.cpp
@@ -1,5 +1,16 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_execve(Thread *thread, ptr<char> fname, ptr<ptr<char>> argv, ptr<ptr<char>> envv) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_fexecve(Thread *thread, sint fd, ptr<ptr<char>> argv, ptr<ptr<char>> envv) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys___mac_execve(Thread *thread, ptr<char> fname, ptr<ptr<char>> argv, ptr<ptr<char>> envv, ptr<struct mac> mac_p) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_execve(Thread *thread, ptr<char> fname,
+                                   ptr<ptr<char>> argv, ptr<ptr<char>> envv) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_fexecve(Thread *thread, sint fd,
+                                    ptr<ptr<char>> argv, ptr<ptr<char>> envv) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys___mac_execve(Thread *thread, ptr<char> fname,
+                                         ptr<ptr<char>> argv,
+                                         ptr<ptr<char>> envv,
+                                         ptr<struct mac> mac_p) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_exit.cpp b/orbis-kernel/src/sys/sys_exit.cpp
index 70fff4b0c..d025e92bc 100644
--- a/orbis-kernel/src/sys/sys_exit.cpp
+++ b/orbis-kernel/src/sys/sys_exit.cpp
@@ -7,7 +7,11 @@ orbis::SysResult orbis::sys_exit(Thread *thread, sint status) {
 
   return ErrorCode::NOSYS;
 }
-orbis::SysResult orbis::sys_abort2(Thread *thread, ptr<const char> why, sint narg, ptr<ptr<void>> args) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_wait4(Thread *thread, sint pid, ptr<sint> status, sint options, ptr<struct rusage> rusage) { return ErrorCode::NOSYS; }
-
-
+orbis::SysResult orbis::sys_abort2(Thread *thread, ptr<const char> why,
+                                   sint narg, ptr<ptr<void>> args) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_wait4(Thread *thread, sint pid, ptr<sint> status,
+                                  sint options, ptr<struct rusage> rusage) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_fork.cpp b/orbis-kernel/src/sys/sys_fork.cpp
index 2238a8580..52b0c472d 100644
--- a/orbis-kernel/src/sys/sys_fork.cpp
+++ b/orbis-kernel/src/sys/sys_fork.cpp
@@ -1,6 +1,10 @@
 #include "sys/sysproto.hpp"
 
 orbis::SysResult orbis::sys_fork(Thread *thread) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_pdfork(Thread *thread, ptr<sint> fdp, sint flags) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_pdfork(Thread *thread, ptr<sint> fdp, sint flags) {
+  return ErrorCode::NOSYS;
+}
 orbis::SysResult orbis::sys_vfork(Thread *thread) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_rfork(Thread *thread, sint flags) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_rfork(Thread *thread, sint flags) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_generic.cpp b/orbis-kernel/src/sys/sys_generic.cpp
index d2e05ba45..5ab5eb3fe 100644
--- a/orbis-kernel/src/sys/sys_generic.cpp
+++ b/orbis-kernel/src/sys/sys_generic.cpp
@@ -1,64 +1,111 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_read(Thread *thread, sint fd, ptr<void> buf, size_t nbyte) {
+orbis::SysResult orbis::sys_read(Thread *thread, sint fd, ptr<void> buf,
+                                 size_t nbyte) {
   if (auto read = thread->tproc->ops->read) {
     return read(thread, fd, buf, nbyte);
   }
 
   return ErrorCode::NOSYS;
 }
-orbis::SysResult orbis::sys_pread(Thread *thread, sint fd, ptr<void> buf, size_t nbyte, off_t offset) {
+orbis::SysResult orbis::sys_pread(Thread *thread, sint fd, ptr<void> buf,
+                                  size_t nbyte, off_t offset) {
   if (auto pread = thread->tproc->ops->pread) {
     return pread(thread, fd, buf, nbyte, offset);
   }
 
   return ErrorCode::NOSYS;
 }
-orbis::SysResult orbis::sys_freebsd6_pread(Thread *thread, sint fd, ptr<void> buf, size_t nbyte, sint, off_t offset) {
+orbis::SysResult orbis::sys_freebsd6_pread(Thread *thread, sint fd,
+                                           ptr<void> buf, size_t nbyte, sint,
+                                           off_t offset) {
   return sys_pread(thread, fd, buf, nbyte, offset);
 }
-orbis::SysResult orbis::sys_readv(Thread *thread, sint fd, ptr<struct iovec> iovp, uint iovcnt) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_preadv(Thread *thread, sint fd, ptr<struct iovec> iovp, uint iovcnt, off_t offset) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_write(Thread *thread, sint fd, ptr<const void> buf, size_t nbyte) {
+orbis::SysResult orbis::sys_readv(Thread *thread, sint fd,
+                                  ptr<struct iovec> iovp, uint iovcnt) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_preadv(Thread *thread, sint fd,
+                                   ptr<struct iovec> iovp, uint iovcnt,
+                                   off_t offset) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_write(Thread *thread, sint fd, ptr<const void> buf,
+                                  size_t nbyte) {
   if (auto write = thread->tproc->ops->write) {
     return write(thread, fd, buf, nbyte);
   }
 
   return ErrorCode::NOSYS;
 }
-orbis::SysResult orbis::sys_pwrite(Thread *thread, sint fd, ptr<const void> buf, size_t nbyte, off_t offset) {
+orbis::SysResult orbis::sys_pwrite(Thread *thread, sint fd, ptr<const void> buf,
+                                   size_t nbyte, off_t offset) {
   if (auto pwrite = thread->tproc->ops->pwrite) {
     return pwrite(thread, fd, buf, nbyte, offset);
   }
   return ErrorCode::NOSYS;
 }
-orbis::SysResult orbis::sys_freebsd6_pwrite(Thread *thread, sint fd, ptr<const void> buf, size_t nbyte, sint, off_t offset) {
+orbis::SysResult orbis::sys_freebsd6_pwrite(Thread *thread, sint fd,
+                                            ptr<const void> buf, size_t nbyte,
+                                            sint, off_t offset) {
   return sys_pwrite(thread, fd, buf, nbyte, offset);
 }
-orbis::SysResult orbis::sys_writev(Thread *thread, sint fd, ptr<struct iovec> iovp, uint iovcnt) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_pwritev(Thread *thread, sint fd, ptr<struct iovec> iovp, uint iovcnt, off_t offset) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_writev(Thread *thread, sint fd,
+                                   ptr<struct iovec> iovp, uint iovcnt) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_pwritev(Thread *thread, sint fd,
+                                    ptr<struct iovec> iovp, uint iovcnt,
+                                    off_t offset) {
+  return ErrorCode::NOSYS;
+}
 orbis::SysResult orbis::sys_ftruncate(Thread *thread, sint fd, off_t length) {
   if (auto ftruncate = thread->tproc->ops->ftruncate) {
     return ftruncate(thread, fd, length);
   }
   return ErrorCode::NOSYS;
 }
-orbis::SysResult orbis::sys_freebsd6_ftruncate(Thread *thread, sint fd, sint, off_t length) {
+orbis::SysResult orbis::sys_freebsd6_ftruncate(Thread *thread, sint fd, sint,
+                                               off_t length) {
   return sys_ftruncate(thread, fd, length);
 }
-orbis::SysResult orbis::sys_ioctl(Thread *thread, sint fd, ulong com, caddr_t data) {
+orbis::SysResult orbis::sys_ioctl(Thread *thread, sint fd, ulong com,
+                                  caddr_t data) {
   if (auto ioctl = thread->tproc->ops->ioctl) {
     return ioctl(thread, fd, com, data);
   }
   return ErrorCode::NOSYS;
 }
-orbis::SysResult orbis::sys_pselect(Thread *thread, sint nd, ptr<fd_set> in, ptr<fd_set> ou, ptr<fd_set> ex, ptr<const struct timespec> ts, ptr<const sigset_t> sm) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_select(Thread *thread, sint nd, ptr<struct fd_set_t> in, ptr<struct fd_set_t> out, ptr<struct fd_set_t> ex, ptr<struct timeval> tv) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_poll(Thread *thread, ptr<struct pollfd> fds, uint nfds, sint timeout) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_openbsd_poll(Thread *thread, ptr<struct pollfd> fds, uint nfds, sint timeout) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_pselect(Thread *thread, sint nd, ptr<fd_set> in,
+                                    ptr<fd_set> ou, ptr<fd_set> ex,
+                                    ptr<const struct timespec> ts,
+                                    ptr<const sigset_t> sm) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_select(Thread *thread, sint nd,
+                                   ptr<struct fd_set_t> in,
+                                   ptr<struct fd_set_t> out,
+                                   ptr<struct fd_set_t> ex,
+                                   ptr<struct timeval> tv) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_poll(Thread *thread, ptr<struct pollfd> fds,
+                                 uint nfds, sint timeout) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_openbsd_poll(Thread *thread, ptr<struct pollfd> fds,
+                                         uint nfds, sint timeout) {
+  return ErrorCode::NOSYS;
+}
 
-orbis::SysResult orbis::sys_nlm_syscall(Thread *thread, sint debug_level, sint grace_period, sint addr_count, ptr<ptr<char>> addrs) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_nfssvc(Thread *thread, sint flag, caddr_t argp) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_nlm_syscall(Thread *thread, sint debug_level,
+                                        sint grace_period, sint addr_count,
+                                        ptr<ptr<char>> addrs) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_nfssvc(Thread *thread, sint flag, caddr_t argp) {
+  return ErrorCode::NOSYS;
+}
 orbis::SysResult orbis::sys_sysarch(Thread *thread, sint op, ptr<char> parms) {
   if (op == 129) {
     auto fs = uread((ptr<uint64_t>)parms);
@@ -70,6 +117,18 @@ orbis::SysResult orbis::sys_sysarch(Thread *thread, sint op, ptr<char> parms) {
   std::printf("sys_sysarch(op = %d, parms = %p): unknown op\n", op, parms);
   return {};
 }
-orbis::SysResult orbis::sys_nnpfs_syscall(Thread *thread, sint operation, ptr<char> a_pathP, sint opcode, ptr<void> a_paramsP, sint a_followSymlinks) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_afs3_syscall(Thread *thread, slong syscall, slong param1, slong param2, slong param3, slong param4, slong param5, slong param6) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_gssd_syscall(Thread *thread, ptr<char> path) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_nnpfs_syscall(Thread *thread, sint operation,
+                                          ptr<char> a_pathP, sint opcode,
+                                          ptr<void> a_paramsP,
+                                          sint a_followSymlinks) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_afs3_syscall(Thread *thread, slong syscall,
+                                         slong param1, slong param2,
+                                         slong param3, slong param4,
+                                         slong param5, slong param6) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_gssd_syscall(Thread *thread, ptr<char> path) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_jail.cpp b/orbis-kernel/src/sys/sys_jail.cpp
index c935367a7..323284a2a 100644
--- a/orbis-kernel/src/sys/sys_jail.cpp
+++ b/orbis-kernel/src/sys/sys_jail.cpp
@@ -1,7 +1,19 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_jail(Thread *thread, ptr<struct jail> jail) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_jail_set(Thread *thread, ptr<struct iovec> iovp, uint iovcnt, sint flags) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_jail_get(Thread *thread, ptr<struct iovec> iovp, uint iovcnt, sint flags) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_jail_remove(Thread *thread, sint jid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_jail_attach(Thread *thread, sint jid) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_jail(Thread *thread, ptr<struct jail> jail) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_jail_set(Thread *thread, ptr<struct iovec> iovp,
+                                     uint iovcnt, sint flags) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_jail_get(Thread *thread, ptr<struct iovec> iovp,
+                                     uint iovcnt, sint flags) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_jail_remove(Thread *thread, sint jid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_jail_attach(Thread *thread, sint jid) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_ktrace.cpp b/orbis-kernel/src/sys/sys_ktrace.cpp
index 0cfac8749..7d28e0bf6 100644
--- a/orbis-kernel/src/sys/sys_ktrace.cpp
+++ b/orbis-kernel/src/sys/sys_ktrace.cpp
@@ -1,4 +1,10 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_ktrace(Thread *thread, ptr<const char> fname, sint ops, sint facs, sint pit) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_utrace(Thread *thread, ptr<const void> addr, size_t len) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_ktrace(Thread *thread, ptr<const char> fname,
+                                   sint ops, sint facs, sint pit) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_utrace(Thread *thread, ptr<const void> addr,
+                                   size_t len) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_linker.cpp b/orbis-kernel/src/sys/sys_linker.cpp
index c8a8a781c..8f9b67037 100644
--- a/orbis-kernel/src/sys/sys_linker.cpp
+++ b/orbis-kernel/src/sys/sys_linker.cpp
@@ -1,10 +1,29 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_kldload(Thread *thread, ptr<const char> file) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_kldunload(Thread *thread, sint fileid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_kldunloadf(Thread *thread, slong fileid, sint flags) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_kldfind(Thread *thread, ptr<const char> name) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_kldnext(Thread *thread, sint fileid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_kldstat(Thread *thread, sint fileid, ptr<struct kld_file_stat> stat) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_kldfirstmod(Thread *thread, sint fileid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_kldsym(Thread *thread, sint fileid, sint cmd, ptr<void> data) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_kldload(Thread *thread, ptr<const char> file) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_kldunload(Thread *thread, sint fileid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_kldunloadf(Thread *thread, slong fileid,
+                                       sint flags) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_kldfind(Thread *thread, ptr<const char> name) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_kldnext(Thread *thread, sint fileid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_kldstat(Thread *thread, sint fileid,
+                                    ptr<struct kld_file_stat> stat) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_kldfirstmod(Thread *thread, sint fileid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_kldsym(Thread *thread, sint fileid, sint cmd,
+                                   ptr<void> data) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_loginclass.cpp b/orbis-kernel/src/sys/sys_loginclass.cpp
index efa2e18a9..00d1e6553 100644
--- a/orbis-kernel/src/sys/sys_loginclass.cpp
+++ b/orbis-kernel/src/sys/sys_loginclass.cpp
@@ -1,4 +1,9 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_getloginclass(Thread *thread, ptr<char> namebuf, size_t namelen) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_setloginclass(Thread *thread, ptr<char> namebuf) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_getloginclass(Thread *thread, ptr<char> namebuf,
+                                          size_t namelen) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_setloginclass(Thread *thread, ptr<char> namebuf) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_mac.cpp b/orbis-kernel/src/sys/sys_mac.cpp
index 34f7e8552..1f4c501c2 100644
--- a/orbis-kernel/src/sys/sys_mac.cpp
+++ b/orbis-kernel/src/sys/sys_mac.cpp
@@ -1,12 +1,44 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys___mac_get_pid(Thread *thread, pid_t pid, ptr<struct mac> mac_p) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys___mac_get_proc(Thread *thread, ptr<struct mac> mac_p) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys___mac_set_proc(Thread *thread, ptr<struct mac> mac_p) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys___mac_get_fd(Thread *thread, sint fd, ptr<struct mac> mac_p) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys___mac_get_file(Thread *thread, ptr<const char> path, ptr<struct mac> mac_p) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys___mac_set_fd(Thread *thread, sint fd, ptr<struct mac> mac_p) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys___mac_set_file(Thread *thread, ptr<const char> path, ptr<struct mac> mac_p) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys___mac_get_link(Thread *thread, ptr<const char> path_p, ptr<struct mac> mac_p) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys___mac_set_link(Thread *thread, ptr<const char> path_p, ptr<struct mac> mac_p) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_mac_syscall(Thread *thread, ptr<const char> policy, sint call, ptr<void> arg) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys___mac_get_pid(Thread *thread, pid_t pid,
+                                          ptr<struct mac> mac_p) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys___mac_get_proc(Thread *thread,
+                                           ptr<struct mac> mac_p) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys___mac_set_proc(Thread *thread,
+                                           ptr<struct mac> mac_p) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys___mac_get_fd(Thread *thread, sint fd,
+                                         ptr<struct mac> mac_p) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys___mac_get_file(Thread *thread, ptr<const char> path,
+                                           ptr<struct mac> mac_p) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys___mac_set_fd(Thread *thread, sint fd,
+                                         ptr<struct mac> mac_p) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys___mac_set_file(Thread *thread, ptr<const char> path,
+                                           ptr<struct mac> mac_p) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys___mac_get_link(Thread *thread,
+                                           ptr<const char> path_p,
+                                           ptr<struct mac> mac_p) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys___mac_set_link(Thread *thread,
+                                           ptr<const char> path_p,
+                                           ptr<struct mac> mac_p) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_mac_syscall(Thread *thread, ptr<const char> policy,
+                                        sint call, ptr<void> arg) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_module.cpp b/orbis-kernel/src/sys/sys_module.cpp
index 4081bd7d1..84b74a0d2 100644
--- a/orbis-kernel/src/sys/sys_module.cpp
+++ b/orbis-kernel/src/sys/sys_module.cpp
@@ -1,6 +1,15 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_modnext(Thread *thread, sint modid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_modfnext(Thread *thread, sint modid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_modstat(Thread *thread, sint modid, ptr<struct module_stat> stat) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_modfind(Thread *thread, ptr<const char> name) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_modnext(Thread *thread, sint modid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_modfnext(Thread *thread, sint modid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_modstat(Thread *thread, sint modid,
+                                    ptr<struct module_stat> stat) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_modfind(Thread *thread, ptr<const char> name) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_msg.cpp b/orbis-kernel/src/sys/sys_msg.cpp
index dfb71cdde..2a3c7b9b0 100644
--- a/orbis-kernel/src/sys/sys_msg.cpp
+++ b/orbis-kernel/src/sys/sys_msg.cpp
@@ -1,7 +1,22 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_msgctl(Thread *thread, sint msqid, sint cmd, ptr<struct msqid_ds> buf) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_msgget(Thread *thread, key_t key, sint msgflg) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_msgsnd(Thread *thread, sint msqid, ptr<const void> msgp, size_t msgsz, sint msgflg) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_msgrcv(Thread *thread, sint msqid, ptr<void> msgp, size_t msgsz, slong msgtyp, sint msgflg) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_msgsys(Thread *thread, sint which, sint a2, sint a3, sint a4, sint a5, sint a6) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_msgctl(Thread *thread, sint msqid, sint cmd,
+                                   ptr<struct msqid_ds> buf) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_msgget(Thread *thread, key_t key, sint msgflg) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_msgsnd(Thread *thread, sint msqid,
+                                   ptr<const void> msgp, size_t msgsz,
+                                   sint msgflg) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_msgrcv(Thread *thread, sint msqid, ptr<void> msgp,
+                                   size_t msgsz, slong msgtyp, sint msgflg) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_msgsys(Thread *thread, sint which, sint a2, sint a3,
+                                   sint a4, sint a5, sint a6) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_ntptime.cpp b/orbis-kernel/src/sys/sys_ntptime.cpp
index ad20168d8..5a5d6dce0 100644
--- a/orbis-kernel/src/sys/sys_ntptime.cpp
+++ b/orbis-kernel/src/sys/sys_ntptime.cpp
@@ -1,5 +1,13 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_ntp_gettime(Thread *thread, ptr<struct ntptimeval> ntvp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_ntp_adjtime(Thread *thread, ptr<struct timex> tp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_adjtime(Thread *thread, ptr<struct timeval> delta, ptr<struct timeval> olddelta) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_ntp_gettime(Thread *thread,
+                                        ptr<struct ntptimeval> ntvp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_ntp_adjtime(Thread *thread, ptr<struct timex> tp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_adjtime(Thread *thread, ptr<struct timeval> delta,
+                                    ptr<struct timeval> olddelta) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_p1003_1b.cpp b/orbis-kernel/src/sys/sys_p1003_1b.cpp
index ce6f07967..d4c40b2e6 100644
--- a/orbis-kernel/src/sys/sys_p1003_1b.cpp
+++ b/orbis-kernel/src/sys/sys_p1003_1b.cpp
@@ -1,10 +1,35 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_sched_setparam(Thread *thread, pid_t pid, ptr<const struct sched_param> param) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_sched_getparam(Thread *thread, pid_t pid, ptr<struct sched_param> param) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_sched_setscheduler(Thread *thread, pid_t pid, sint policy, ptr<const struct sched_param> param) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_sched_getscheduler(Thread *thread, pid_t pid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_sched_yield(Thread *thread) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_sched_get_priority_max(Thread *thread, sint policy) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_sched_get_priority_min(Thread *thread, sint policy) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_sched_rr_get_interval(Thread *thread, pid_t pid, ptr<struct timespec> interval) { return ErrorCode::NOSYS; }
+orbis::SysResult
+orbis::sys_sched_setparam(Thread *thread, pid_t pid,
+                          ptr<const struct sched_param> param) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_sched_getparam(Thread *thread, pid_t pid,
+                                           ptr<struct sched_param> param) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult
+orbis::sys_sched_setscheduler(Thread *thread, pid_t pid, sint policy,
+                              ptr<const struct sched_param> param) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_sched_getscheduler(Thread *thread, pid_t pid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_sched_yield(Thread *thread) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_sched_get_priority_max(Thread *thread,
+                                                   sint policy) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_sched_get_priority_min(Thread *thread,
+                                                   sint policy) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult
+orbis::sys_sched_rr_get_interval(Thread *thread, pid_t pid,
+                                 ptr<struct timespec> interval) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_procdesc.cpp b/orbis-kernel/src/sys/sys_procdesc.cpp
index 77cd5e515..0ddd003ff 100644
--- a/orbis-kernel/src/sys/sys_procdesc.cpp
+++ b/orbis-kernel/src/sys/sys_procdesc.cpp
@@ -1,3 +1,5 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_pdgetpid(Thread *thread, sint fd, ptr<pid_t> pidp) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_pdgetpid(Thread *thread, sint fd, ptr<pid_t> pidp) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_process.cpp b/orbis-kernel/src/sys/sys_process.cpp
index cc247db84..cf3223fd8 100644
--- a/orbis-kernel/src/sys/sys_process.cpp
+++ b/orbis-kernel/src/sys/sys_process.cpp
@@ -1,3 +1,6 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_ptrace(Thread *thread, sint req, pid_t pid, caddr_t addr, sint data) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_ptrace(Thread *thread, sint req, pid_t pid,
+                                   caddr_t addr, sint data) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_prot.cpp b/orbis-kernel/src/sys/sys_prot.cpp
index d3ff0cbfa..120a32e8d 100644
--- a/orbis-kernel/src/sys/sys_prot.cpp
+++ b/orbis-kernel/src/sys/sys_prot.cpp
@@ -6,27 +6,72 @@ orbis::SysResult orbis::sys_getpid(Thread *thread) {
 }
 orbis::SysResult orbis::sys_getppid(Thread *thread) { return ErrorCode::NOSYS; }
 orbis::SysResult orbis::sys_getpgrp(Thread *thread) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_getpgid(Thread *thread, pid_t pid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_getsid(Thread *thread, pid_t pid) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_getpgid(Thread *thread, pid_t pid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_getsid(Thread *thread, pid_t pid) {
+  return ErrorCode::NOSYS;
+}
 orbis::SysResult orbis::sys_getuid(Thread *thread) { return ErrorCode::NOSYS; }
 orbis::SysResult orbis::sys_geteuid(Thread *thread) { return ErrorCode::NOSYS; }
 orbis::SysResult orbis::sys_getgid(Thread *thread) { return ErrorCode::NOSYS; }
 orbis::SysResult orbis::sys_getegid(Thread *thread) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_getgroups(Thread *thread, uint gidsetsize, ptr<gid_t> gidset) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_getgroups(Thread *thread, uint gidsetsize,
+                                      ptr<gid_t> gidset) {
+  return ErrorCode::NOSYS;
+}
 orbis::SysResult orbis::sys_setsid(Thread *thread) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_setpgid(Thread *thread, sint pid, sint pgid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_setuid(Thread *thread, uid_t uid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_seteuid(Thread *thread, uid_t euid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_setgid(Thread *thread, gid_t gid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_setegid(Thread *thread, gid_t egid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_setgroups(Thread *thread, uint gidsetsize, ptr<gid_t> gidset) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_setreuid(Thread *thread, sint ruid, sint euid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_setregid(Thread *thread, sint rgid, sint egid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_setresuid(Thread *thread, uid_t ruid, uid_t euid, uid_t suid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_setresgid(Thread *thread, gid_t rgid, gid_t egid, gid_t sgid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_getresuid(Thread *thread, ptr<uid_t> ruid, ptr<uid_t> euid, ptr<uid_t> suid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_getresgid(Thread *thread, ptr<gid_t> rgid, ptr<gid_t> egid, ptr<gid_t> sgid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_issetugid(Thread *thread) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys___setugid(Thread *thread, sint flags) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_getlogin(Thread *thread, ptr<char> namebuf, uint namelen) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_setlogin(Thread *thread, ptr<char> namebuf) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_setpgid(Thread *thread, sint pid, sint pgid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_setuid(Thread *thread, uid_t uid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_seteuid(Thread *thread, uid_t euid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_setgid(Thread *thread, gid_t gid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_setegid(Thread *thread, gid_t egid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_setgroups(Thread *thread, uint gidsetsize,
+                                      ptr<gid_t> gidset) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_setreuid(Thread *thread, sint ruid, sint euid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_setregid(Thread *thread, sint rgid, sint egid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_setresuid(Thread *thread, uid_t ruid, uid_t euid,
+                                      uid_t suid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_setresgid(Thread *thread, gid_t rgid, gid_t egid,
+                                      gid_t sgid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_getresuid(Thread *thread, ptr<uid_t> ruid,
+                                      ptr<uid_t> euid, ptr<uid_t> suid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_getresgid(Thread *thread, ptr<gid_t> rgid,
+                                      ptr<gid_t> egid, ptr<gid_t> sgid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_issetugid(Thread *thread) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys___setugid(Thread *thread, sint flags) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_getlogin(Thread *thread, ptr<char> namebuf,
+                                     uint namelen) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_setlogin(Thread *thread, ptr<char> namebuf) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_pty_pts.cpp b/orbis-kernel/src/sys/sys_pty_pts.cpp
index 6406c3fc9..65b6246a2 100644
--- a/orbis-kernel/src/sys/sys_pty_pts.cpp
+++ b/orbis-kernel/src/sys/sys_pty_pts.cpp
@@ -1,3 +1,5 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_posix_openpt(Thread *thread, sint flags) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_posix_openpt(Thread *thread, sint flags) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_rctl.cpp b/orbis-kernel/src/sys/sys_rctl.cpp
index 7664b8786..a8215e204 100644
--- a/orbis-kernel/src/sys/sys_rctl.cpp
+++ b/orbis-kernel/src/sys/sys_rctl.cpp
@@ -1,7 +1,32 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_rctl_get_racct(Thread *thread, ptr<const void> inbufp, size_t inbuflen, ptr<void> outbuf, size_t outbuflen) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_rctl_get_rules(Thread *thread, ptr<const void> inbufp, size_t inbuflen, ptr<void> outbuf, size_t outbuflen) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_rctl_get_limits(Thread *thread, ptr<const void> inbufp, size_t inbuflen, ptr<void> outbuf, size_t outbuflen) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_rctl_add_rule(Thread *thread, ptr<const void> inbufp, size_t inbuflen, ptr<void> outbuf, size_t outbuflen) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_rctl_remove_rule(Thread *thread, ptr<const void> inbufp, size_t inbuflen, ptr<void> outbuf, size_t outbuflen) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_rctl_get_racct(Thread *thread,
+                                           ptr<const void> inbufp,
+                                           size_t inbuflen, ptr<void> outbuf,
+                                           size_t outbuflen) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_rctl_get_rules(Thread *thread,
+                                           ptr<const void> inbufp,
+                                           size_t inbuflen, ptr<void> outbuf,
+                                           size_t outbuflen) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_rctl_get_limits(Thread *thread,
+                                            ptr<const void> inbufp,
+                                            size_t inbuflen, ptr<void> outbuf,
+                                            size_t outbuflen) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_rctl_add_rule(Thread *thread,
+                                          ptr<const void> inbufp,
+                                          size_t inbuflen, ptr<void> outbuf,
+                                          size_t outbuflen) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_rctl_remove_rule(Thread *thread,
+                                             ptr<const void> inbufp,
+                                             size_t inbuflen, ptr<void> outbuf,
+                                             size_t outbuflen) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_resource.cpp b/orbis-kernel/src/sys/sys_resource.cpp
index 3fab5429d..d8942bccc 100644
--- a/orbis-kernel/src/sys/sys_resource.cpp
+++ b/orbis-kernel/src/sys/sys_resource.cpp
@@ -1,12 +1,31 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_getpriority(Thread *thread, sint which, sint who) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_setpriority(Thread *thread, sint which, sint who, sint prio) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_rtprio_thread(Thread *thread, sint function, lwpid_t lwpid, ptr<struct rtprio> rtp) {
+orbis::SysResult orbis::sys_getpriority(Thread *thread, sint which, sint who) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_setpriority(Thread *thread, sint which, sint who,
+                                        sint prio) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_rtprio_thread(Thread *thread, sint function,
+                                          lwpid_t lwpid,
+                                          ptr<struct rtprio> rtp) {
   std::printf("sys_rtprio_thread: unimplemented\n");
   return {};
 }
-orbis::SysResult orbis::sys_rtprio(Thread *thread, sint function, pid_t pid, ptr<struct rtprio> rtp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_setrlimit(Thread *thread, uint which, ptr<struct rlimit> rlp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_getrlimit(Thread *thread, uint which, ptr<struct rlimit> rlp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_getrusage(Thread *thread, sint who, ptr<struct rusage> rusage) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_rtprio(Thread *thread, sint function, pid_t pid,
+                                   ptr<struct rtprio> rtp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_setrlimit(Thread *thread, uint which,
+                                      ptr<struct rlimit> rlp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_getrlimit(Thread *thread, uint which,
+                                      ptr<struct rlimit> rlp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_getrusage(Thread *thread, sint who,
+                                      ptr<struct rusage> rusage) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_route.cpp b/orbis-kernel/src/sys/sys_route.cpp
index 3eed54849..a19427e8a 100644
--- a/orbis-kernel/src/sys/sys_route.cpp
+++ b/orbis-kernel/src/sys/sys_route.cpp
@@ -1,3 +1,5 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_setfib(Thread *thread, sint fib) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_setfib(Thread *thread, sint fib) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_sce.cpp b/orbis-kernel/src/sys/sys_sce.cpp
index d16458585..0da5bfa58 100644
--- a/orbis-kernel/src/sys/sys_sce.cpp
+++ b/orbis-kernel/src/sys/sys_sce.cpp
@@ -127,7 +127,7 @@ orbis::SysResult orbis::sys_evf_delete(Thread *thread, sint id) {
     return ErrorCode::SRCH;
   }
 
-   // TODO: do destroy and remove atomically
+  // TODO: do destroy and remove atomically
   evf->destroy();
   thread->tproc->evfMap.remove(id);
 
@@ -163,7 +163,7 @@ orbis::SysResult orbis::sys_evf_wait(Thread *thread, sint id,
                                      ptr<uint> pTimeout) {
   if ((mode & (kEvfWaitModeAnd | kEvfWaitModeOr)) == 0 ||
       (mode & ~(kEvfWaitModeAnd | kEvfWaitModeOr | kEvfWaitModeClearAll |
-               kEvfWaitModeClearPat)) != 0 ||
+                kEvfWaitModeClearPat)) != 0 ||
       patternSet == 0) {
     return ErrorCode::INVAL;
   }
@@ -195,7 +195,7 @@ orbis::SysResult orbis::sys_evf_trywait(Thread *thread, sint id,
                                         ptr<uint64_t> pPatternSet) {
   if ((mode & (kEvfWaitModeAnd | kEvfWaitModeOr)) == 0 ||
       (mode & ~(kEvfWaitModeAnd | kEvfWaitModeOr | kEvfWaitModeClearAll |
-               kEvfWaitModeClearPat)) != 0 ||
+                kEvfWaitModeClearPat)) != 0 ||
       patternSet == 0) {
     return ErrorCode::INVAL;
   }
@@ -207,7 +207,8 @@ orbis::SysResult orbis::sys_evf_trywait(Thread *thread, sint id,
   }
 
   std::uint64_t resultPattern{};
-  auto result = evf->tryWait(thread, mode, patternSet, pPatternSet != nullptr ? &resultPattern : nullptr);
+  auto result = evf->tryWait(thread, mode, patternSet,
+                             pPatternSet != nullptr ? &resultPattern : nullptr);
 
   if (pPatternSet != nullptr) {
     uwrite(pPatternSet, (uint64_t)resultPattern);
@@ -223,7 +224,7 @@ orbis::SysResult orbis::sys_evf_set(Thread *thread, sint id, uint64_t value) {
   }
 
   evf->set(value);
-  return{};
+  return {};
 }
 orbis::SysResult orbis::sys_evf_clear(Thread *thread, sint id, uint64_t value) {
   Ref<EventFlag> evf = thread->tproc->evfMap.get(id);
@@ -233,9 +234,10 @@ orbis::SysResult orbis::sys_evf_clear(Thread *thread, sint id, uint64_t value) {
   }
 
   evf->clear(value);
-  return{};
+  return {};
 }
-orbis::SysResult orbis::sys_evf_cancel(Thread *thread, sint id, uint64_t value, ptr<sint> pNumWaitThreads) {
+orbis::SysResult orbis::sys_evf_cancel(Thread *thread, sint id, uint64_t value,
+                                       ptr<sint> pNumWaitThreads) {
   Ref<EventFlag> evf = thread->tproc->evfMap.get(id);
 
   if (evf == nullptr) {
@@ -246,7 +248,7 @@ orbis::SysResult orbis::sys_evf_cancel(Thread *thread, sint id, uint64_t value,
   if (pNumWaitThreads != nullptr) {
     *pNumWaitThreads = numWaitThreads;
   }
-  return{};
+  return {};
 }
 orbis::SysResult orbis::sys_query_memory_protection(Thread *thread /* TODO */) {
   return ErrorCode::NOSYS;
diff --git a/orbis-kernel/src/sys/sys_sem.cpp b/orbis-kernel/src/sys/sys_sem.cpp
index 9a3765b01..039e10ea3 100644
--- a/orbis-kernel/src/sys/sys_sem.cpp
+++ b/orbis-kernel/src/sys/sys_sem.cpp
@@ -1,6 +1,18 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys___semctl(Thread *thread, sint semid, sint semnum, sint cmd, ptr<union semun> arg) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_semget(Thread *thread, key_t key, sint nsems, sint semflg) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_semop(Thread *thread, sint semid, ptr<struct sembuf> sops, size_t nspos) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_semsys(Thread *thread, sint which, sint a2, sint a3, sint a4, sint a5) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys___semctl(Thread *thread, sint semid, sint semnum,
+                                     sint cmd, ptr<union semun> arg) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_semget(Thread *thread, key_t key, sint nsems,
+                                   sint semflg) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_semop(Thread *thread, sint semid,
+                                  ptr<struct sembuf> sops, size_t nspos) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_semsys(Thread *thread, sint which, sint a2, sint a3,
+                                   sint a4, sint a5) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_shm.cpp b/orbis-kernel/src/sys/sys_shm.cpp
index 7c4da1876..c70615540 100644
--- a/orbis-kernel/src/sys/sys_shm.cpp
+++ b/orbis-kernel/src/sys/sys_shm.cpp
@@ -1,7 +1,21 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_shmdt(Thread *thread, ptr<const void> shmaddr) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_shmat(Thread *thread, sint shmid, ptr<const void> shmaddr, sint shmflg) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_shmctl(Thread *thread, sint shmid, sint cmd, ptr<struct shmid_ds> buf) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_shmget(Thread *thread, key_t key, size_t size, sint shmflg) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_shmsys(Thread *thread, sint which, sint a2, sint a3, sint a4) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_shmdt(Thread *thread, ptr<const void> shmaddr) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_shmat(Thread *thread, sint shmid,
+                                  ptr<const void> shmaddr, sint shmflg) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_shmctl(Thread *thread, sint shmid, sint cmd,
+                                   ptr<struct shmid_ds> buf) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_shmget(Thread *thread, key_t key, size_t size,
+                                   sint shmflg) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_shmsys(Thread *thread, sint which, sint a2, sint a3,
+                                   sint a4) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_shutdown.cpp b/orbis-kernel/src/sys/sys_shutdown.cpp
index 965b5d20f..496a09056 100644
--- a/orbis-kernel/src/sys/sys_shutdown.cpp
+++ b/orbis-kernel/src/sys/sys_shutdown.cpp
@@ -1,3 +1,5 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_reboot(Thread *thread, sint opt) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_reboot(Thread *thread, sint opt) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_sig.cpp b/orbis-kernel/src/sys/sys_sig.cpp
index 6716b94e0..28fd09137 100644
--- a/orbis-kernel/src/sys/sys_sig.cpp
+++ b/orbis-kernel/src/sys/sys_sig.cpp
@@ -1,7 +1,12 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_sigaction(Thread *thread, sint sig, ptr<struct sigaction> act, ptr<struct sigaction> oact) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_sigprocmask(Thread *thread, sint how, ptr<uint64_t> set, ptr<uint64_t> oset) {
+orbis::SysResult orbis::sys_sigaction(Thread *thread, sint sig,
+                                      ptr<struct sigaction> act,
+                                      ptr<struct sigaction> oact) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_sigprocmask(Thread *thread, sint how,
+                                        ptr<uint64_t> set, ptr<uint64_t> oset) {
   if (oset) {
     for (std::size_t i = 0; i < 2; ++i) {
       oset[i] = thread->sigMask[i];
@@ -31,14 +36,45 @@ orbis::SysResult orbis::sys_sigprocmask(Thread *thread, sint how, ptr<uint64_t>
   }
   return {};
 }
-orbis::SysResult orbis::sys_sigwait(Thread *thread, ptr<const struct sigset> set, ptr<sint> sig) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_sigtimedwait(Thread *thread, ptr<const struct sigset> set, ptr<struct siginfo> info, ptr<const struct timespec> timeout) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_sigwaitinfo(Thread *thread, ptr<const struct sigset> set, ptr<struct siginfo> info) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_sigpending(Thread *thread, ptr<struct sigset> set) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_sigsuspend(Thread *thread, ptr<const struct sigset> set) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_sigaltstack(Thread *thread, ptr<struct stack_t> ss, ptr<struct stack_t> oss) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_kill(Thread *thread, sint pid, sint signum) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_pdkill(Thread *thread, sint fd, sint signum) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_sigqueue(Thread *thread, pid_t pid, sint signum, ptr<void> value) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_sigreturn(Thread *thread, ptr<struct ucontext> sigcntxp) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_sigwait(Thread *thread,
+                                    ptr<const struct sigset> set,
+                                    ptr<sint> sig) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_sigtimedwait(Thread *thread,
+                                         ptr<const struct sigset> set,
+                                         ptr<struct siginfo> info,
+                                         ptr<const struct timespec> timeout) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_sigwaitinfo(Thread *thread,
+                                        ptr<const struct sigset> set,
+                                        ptr<struct siginfo> info) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_sigpending(Thread *thread, ptr<struct sigset> set) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_sigsuspend(Thread *thread,
+                                       ptr<const struct sigset> set) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_sigaltstack(Thread *thread, ptr<struct stack_t> ss,
+                                        ptr<struct stack_t> oss) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_kill(Thread *thread, sint pid, sint signum) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_pdkill(Thread *thread, sint fd, sint signum) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_sigqueue(Thread *thread, pid_t pid, sint signum,
+                                     ptr<void> value) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_sigreturn(Thread *thread,
+                                      ptr<struct ucontext> sigcntxp) {
+  return ErrorCode::NOSYS;
+}
 orbis::SysResult orbis::nosys(Thread *thread) { return ErrorCode::NOSYS; }
diff --git a/orbis-kernel/src/sys/sys_subr_prof.cpp b/orbis-kernel/src/sys/sys_subr_prof.cpp
index cf6f65461..37ac49965 100644
--- a/orbis-kernel/src/sys/sys_subr_prof.cpp
+++ b/orbis-kernel/src/sys/sys_subr_prof.cpp
@@ -1,3 +1,6 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_profil(Thread *thread, caddr_t samples, size_t size, size_t offset, uint scale) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_profil(Thread *thread, caddr_t samples, size_t size,
+                                   size_t offset, uint scale) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_swap_pager.cpp b/orbis-kernel/src/sys/sys_swap_pager.cpp
index 8e1559613..1313f8fe9 100644
--- a/orbis-kernel/src/sys/sys_swap_pager.cpp
+++ b/orbis-kernel/src/sys/sys_swap_pager.cpp
@@ -1,4 +1,8 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_swapon(Thread *thread, ptr<char> name) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_swapoff(Thread *thread, ptr<const char> name) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_swapon(Thread *thread, ptr<char> name) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_swapoff(Thread *thread, ptr<const char> name) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_thr.cpp b/orbis-kernel/src/sys/sys_thr.cpp
index dcef55f1e..a7b1dbc3a 100644
--- a/orbis-kernel/src/sys/sys_thr.cpp
+++ b/orbis-kernel/src/sys/sys_thr.cpp
@@ -1,6 +1,8 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_thr_create(Thread *thread, ptr<struct ucontext> ctxt, ptr<slong> arg, sint flags) {
+orbis::SysResult orbis::sys_thr_create(Thread *thread,
+                                       ptr<struct ucontext> ctxt,
+                                       ptr<slong> arg, sint flags) {
   if (auto thr_create = thread->tproc->ops->thr_create) {
     return thr_create(thread, ctxt, arg, flags);
   }
@@ -8,7 +10,8 @@ orbis::SysResult orbis::sys_thr_create(Thread *thread, ptr<struct ucontext> ctxt
   return ErrorCode::NOSYS;
 }
 
-orbis::SysResult orbis::sys_thr_new(Thread *thread, ptr<struct thr_param> param, sint param_size) {
+orbis::SysResult orbis::sys_thr_new(Thread *thread, ptr<struct thr_param> param,
+                                    sint param_size) {
   if (auto thr_new = thread->tproc->ops->thr_new) {
     return thr_new(thread, param, param_size);
   }
@@ -36,7 +39,8 @@ orbis::SysResult orbis::sys_thr_kill(Thread *thread, slong id, sint sig) {
   return ErrorCode::NOSYS;
 }
 
-orbis::SysResult orbis::sys_thr_kill2(Thread *thread, pid_t pid, slong id, sint sig) {
+orbis::SysResult orbis::sys_thr_kill2(Thread *thread, pid_t pid, slong id,
+                                      sint sig) {
   if (auto thr_kill2 = thread->tproc->ops->thr_kill2) {
     return thr_kill2(thread, pid, id, sig);
   }
@@ -44,7 +48,8 @@ orbis::SysResult orbis::sys_thr_kill2(Thread *thread, pid_t pid, slong id, sint
   return ErrorCode::NOSYS;
 }
 
-orbis::SysResult orbis::sys_thr_suspend(Thread *thread, ptr<const struct timespec> timeout) {
+orbis::SysResult orbis::sys_thr_suspend(Thread *thread,
+                                        ptr<const struct timespec> timeout) {
   if (auto thr_suspend = thread->tproc->ops->thr_suspend) {
     return thr_suspend(thread, timeout);
   }
@@ -60,7 +65,8 @@ orbis::SysResult orbis::sys_thr_wake(Thread *thread, slong id) {
   return ErrorCode::NOSYS;
 }
 
-orbis::SysResult orbis::sys_thr_set_name(Thread *thread, slong id, ptr<const char> name) {
+orbis::SysResult orbis::sys_thr_set_name(Thread *thread, slong id,
+                                         ptr<const char> name) {
   if (auto thr_set_name = thread->tproc->ops->thr_set_name) {
     return thr_set_name(thread, id, name);
   }
diff --git a/orbis-kernel/src/sys/sys_time.cpp b/orbis-kernel/src/sys/sys_time.cpp
index d4f3709c0..25d8161a9 100644
--- a/orbis-kernel/src/sys/sys_time.cpp
+++ b/orbis-kernel/src/sys/sys_time.cpp
@@ -1,15 +1,57 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_clock_gettime(Thread *thread, clockid_t clock_id, ptr<struct timespec> tp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_clock_settime(Thread *thread, clockid_t clock_id, ptr<const struct timespec> tp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_clock_getres(Thread *thread, clockid_t clock_id, ptr<struct timespec> tp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_nanosleep(Thread *thread, ptr<const struct timespec> rqtp, ptr<struct timespec> rmtp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_gettimeofday(Thread *thread, ptr<struct timeval> tp, ptr<struct timezone> tzp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_settimeofday(Thread *thread, ptr<struct timeval> tp, ptr<struct timezone> tzp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_getitimer(Thread *thread, uint which, ptr<struct itimerval> itv) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_setitimer(Thread *thread, uint which, ptr<struct itimerval> itv, ptr<struct itimerval> oitv) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_ktimer_create(Thread *thread, clockid_t clock_id, ptr<struct sigevent> evp, ptr<sint> timerid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_ktimer_delete(Thread *thread, sint timerid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_ktimer_settime(Thread *thread, sint timerid, sint flags, ptr<const struct itimerspec> value, ptr<struct itimerspec> ovalue) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_ktimer_gettime(Thread *thread, sint timerid, ptr<struct itimerspec> value) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_ktimer_getoverrun(Thread *thread, sint timerid) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_clock_gettime(Thread *thread, clockid_t clock_id,
+                                          ptr<struct timespec> tp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_clock_settime(Thread *thread, clockid_t clock_id,
+                                          ptr<const struct timespec> tp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_clock_getres(Thread *thread, clockid_t clock_id,
+                                         ptr<struct timespec> tp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_nanosleep(Thread *thread,
+                                      ptr<const struct timespec> rqtp,
+                                      ptr<struct timespec> rmtp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_gettimeofday(Thread *thread, ptr<struct timeval> tp,
+                                         ptr<struct timezone> tzp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_settimeofday(Thread *thread, ptr<struct timeval> tp,
+                                         ptr<struct timezone> tzp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_getitimer(Thread *thread, uint which,
+                                      ptr<struct itimerval> itv) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_setitimer(Thread *thread, uint which,
+                                      ptr<struct itimerval> itv,
+                                      ptr<struct itimerval> oitv) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_ktimer_create(Thread *thread, clockid_t clock_id,
+                                          ptr<struct sigevent> evp,
+                                          ptr<sint> timerid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_ktimer_delete(Thread *thread, sint timerid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_ktimer_settime(Thread *thread, sint timerid,
+                                           sint flags,
+                                           ptr<const struct itimerspec> value,
+                                           ptr<struct itimerspec> ovalue) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_ktimer_gettime(Thread *thread, sint timerid,
+                                           ptr<struct itimerspec> value) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_ktimer_getoverrun(Thread *thread, sint timerid) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_uipc.cpp b/orbis-kernel/src/sys/sys_uipc.cpp
index a72997f06..244c1944a 100644
--- a/orbis-kernel/src/sys/sys_uipc.cpp
+++ b/orbis-kernel/src/sys/sys_uipc.cpp
@@ -1,22 +1,94 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_socket(Thread *thread, sint domain, sint type, sint protocol) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_bind(Thread *thread, sint s, caddr_t name, sint namelen) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_listen(Thread *thread, sint s, sint backlog) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_accept(Thread *thread, sint s, ptr<struct sockaddr> from, ptr<uint32_t> fromlenaddr) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_connect(Thread *thread, sint s, caddr_t name, sint namelen) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_socketpair(Thread *thread, sint domain, sint type, sint protocol, ptr<sint> rsv) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_sendto(Thread *thread, sint s, caddr_t buf, size_t len, sint flags, caddr_t to, sint tolen) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_sendmsg(Thread *thread, sint s, ptr<struct msghdr> msg, sint flags) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_recvfrom(Thread *thread, sint s, caddr_t buf, size_t len, sint flags, ptr<struct sockaddr> from, ptr<uint32_t> fromlenaddr) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_recvmsg(Thread *thread, sint s, ptr<struct msghdr> msg, sint flags) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_shutdown(Thread *thread, sint s, sint how) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_setsockopt(Thread *thread, sint s, sint level, sint name, caddr_t val, sint valsize) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_getsockopt(Thread *thread, sint s, sint level, sint name, caddr_t val, ptr<sint> avalsize) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_getsockname(Thread *thread, sint fdes, ptr<struct sockaddr> asa, ptr<uint32_t> alen) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_getpeername(Thread *thread, sint fdes, ptr<struct sockaddr> asa, ptr<uint32_t> alen) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_sendfile(Thread *thread, sint fd, sint s, off_t offset, size_t nbytes, ptr<struct sf_hdtr> hdtr, ptr<off_t> sbytes, sint flags) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_sctp_peeloff(Thread *thread, sint sd, uint32_t name) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_sctp_generic_sendmsg(Thread *thread, sint sd, caddr_t msg, sint mlen, caddr_t to, __socklen_t tolen, ptr<struct sctp_sndrcvinfo> sinfo, sint flags) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_sctp_generic_sendmsg_iov(Thread *thread, sint sd, ptr<struct iovec> iov, sint iovlen, caddr_t to, __socklen_t tolen, ptr<struct sctp_sndrcvinfo> sinfo, sint flags) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_sctp_generic_recvmsg(Thread *thread, sint sd, ptr<struct iovec> iov, sint iovlen, caddr_t from, __socklen_t fromlen, ptr<struct sctp_sndrcvinfo> sinfo, sint flags) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_socket(Thread *thread, sint domain, sint type,
+                                   sint protocol) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_bind(Thread *thread, sint s, caddr_t name,
+                                 sint namelen) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_listen(Thread *thread, sint s, sint backlog) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_accept(Thread *thread, sint s,
+                                   ptr<struct sockaddr> from,
+                                   ptr<uint32_t> fromlenaddr) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_connect(Thread *thread, sint s, caddr_t name,
+                                    sint namelen) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_socketpair(Thread *thread, sint domain, sint type,
+                                       sint protocol, ptr<sint> rsv) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_sendto(Thread *thread, sint s, caddr_t buf,
+                                   size_t len, sint flags, caddr_t to,
+                                   sint tolen) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_sendmsg(Thread *thread, sint s,
+                                    ptr<struct msghdr> msg, sint flags) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_recvfrom(Thread *thread, sint s, caddr_t buf,
+                                     size_t len, sint flags,
+                                     ptr<struct sockaddr> from,
+                                     ptr<uint32_t> fromlenaddr) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_recvmsg(Thread *thread, sint s,
+                                    ptr<struct msghdr> msg, sint flags) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_shutdown(Thread *thread, sint s, sint how) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_setsockopt(Thread *thread, sint s, sint level,
+                                       sint name, caddr_t val, sint valsize) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_getsockopt(Thread *thread, sint s, sint level,
+                                       sint name, caddr_t val,
+                                       ptr<sint> avalsize) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_getsockname(Thread *thread, sint fdes,
+                                        ptr<struct sockaddr> asa,
+                                        ptr<uint32_t> alen) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_getpeername(Thread *thread, sint fdes,
+                                        ptr<struct sockaddr> asa,
+                                        ptr<uint32_t> alen) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_sendfile(Thread *thread, sint fd, sint s,
+                                     off_t offset, size_t nbytes,
+                                     ptr<struct sf_hdtr> hdtr,
+                                     ptr<off_t> sbytes, sint flags) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_sctp_peeloff(Thread *thread, sint sd,
+                                         uint32_t name) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult
+orbis::sys_sctp_generic_sendmsg(Thread *thread, sint sd, caddr_t msg, sint mlen,
+                                caddr_t to, __socklen_t tolen,
+                                ptr<struct sctp_sndrcvinfo> sinfo, sint flags) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_sctp_generic_sendmsg_iov(
+    Thread *thread, sint sd, ptr<struct iovec> iov, sint iovlen, caddr_t to,
+    __socklen_t tolen, ptr<struct sctp_sndrcvinfo> sinfo, sint flags) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult
+orbis::sys_sctp_generic_recvmsg(Thread *thread, sint sd, ptr<struct iovec> iov,
+                                sint iovlen, caddr_t from, __socklen_t fromlen,
+                                ptr<struct sctp_sndrcvinfo> sinfo, sint flags) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_uipc_mqueue.cpp b/orbis-kernel/src/sys/sys_uipc_mqueue.cpp
index 045bcc2d5..7a21dee07 100644
--- a/orbis-kernel/src/sys/sys_uipc_mqueue.cpp
+++ b/orbis-kernel/src/sys/sys_uipc_mqueue.cpp
@@ -1,8 +1,31 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_kmq_open(Thread *thread, ptr<const char> path, sint flags, mode_t mode, ptr<const struct mq_attr> attr) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_kmq_unlink(Thread *thread, ptr<const char> path) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_kmq_setattr(Thread *thread, sint mqd, ptr<const struct mq_attr> attr, ptr<struct mq_attr> oattr) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_kmq_timedreceive(Thread *thread, sint mqd, ptr<const char> msg_ptr, size_t msg_len, ptr<uint> msg_prio, ptr<const struct timespec> abstimeout) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_kmq_timedsend(Thread *thread, sint mqd, ptr<char> msg_ptr, size_t msg_len, ptr<uint> msg_prio, ptr<const struct timespec> abstimeout) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_kmq_notify(Thread *thread, sint mqd, ptr<const struct sigevent> sigev) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_kmq_open(Thread *thread, ptr<const char> path,
+                                     sint flags, mode_t mode,
+                                     ptr<const struct mq_attr> attr) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_kmq_unlink(Thread *thread, ptr<const char> path) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_kmq_setattr(Thread *thread, sint mqd,
+                                        ptr<const struct mq_attr> attr,
+                                        ptr<struct mq_attr> oattr) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult
+orbis::sys_kmq_timedreceive(Thread *thread, sint mqd, ptr<const char> msg_ptr,
+                            size_t msg_len, ptr<uint> msg_prio,
+                            ptr<const struct timespec> abstimeout) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult
+orbis::sys_kmq_timedsend(Thread *thread, sint mqd, ptr<char> msg_ptr,
+                         size_t msg_len, ptr<uint> msg_prio,
+                         ptr<const struct timespec> abstimeout) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_kmq_notify(Thread *thread, sint mqd,
+                                       ptr<const struct sigevent> sigev) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_uipc_sem.cpp b/orbis-kernel/src/sys/sys_uipc_sem.cpp
index b7eab485b..fa38bac80 100644
--- a/orbis-kernel/src/sys/sys_uipc_sem.cpp
+++ b/orbis-kernel/src/sys/sys_uipc_sem.cpp
@@ -1,12 +1,37 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_ksem_init(Thread *thread, ptr<semid_t> idp, uint value) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_ksem_open(Thread *thread, ptr<semid_t> idp, ptr<const char> name, sint oflag, mode_t mode, uint value) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_ksem_unlink(Thread *thread, ptr<const char> name) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_ksem_close(Thread *thread, semid_t id) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_ksem_post(Thread *thread, semid_t id) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_ksem_wait(Thread *thread, semid_t id) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_ksem_timedwait(Thread *thread, semid_t id, ptr<const struct timespec> abstime) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_ksem_trywait(Thread *thread, semid_t id) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_ksem_getvalue(Thread *thread, semid_t id, ptr<sint> value) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_ksem_destroy(Thread *thread, semid_t id) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_ksem_init(Thread *thread, ptr<semid_t> idp,
+                                      uint value) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_ksem_open(Thread *thread, ptr<semid_t> idp,
+                                      ptr<const char> name, sint oflag,
+                                      mode_t mode, uint value) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_ksem_unlink(Thread *thread, ptr<const char> name) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_ksem_close(Thread *thread, semid_t id) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_ksem_post(Thread *thread, semid_t id) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_ksem_wait(Thread *thread, semid_t id) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_ksem_timedwait(Thread *thread, semid_t id,
+                                           ptr<const struct timespec> abstime) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_ksem_trywait(Thread *thread, semid_t id) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_ksem_getvalue(Thread *thread, semid_t id,
+                                          ptr<sint> value) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_ksem_destroy(Thread *thread, semid_t id) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_uipc_shm.cpp b/orbis-kernel/src/sys/sys_uipc_shm.cpp
index 79ae5dbcb..51f38feea 100644
--- a/orbis-kernel/src/sys/sys_uipc_shm.cpp
+++ b/orbis-kernel/src/sys/sys_uipc_shm.cpp
@@ -1,4 +1,9 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_shm_open(Thread *thread, ptr<const char> path, sint flags, mode_t mode) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_shm_unlink(Thread *thread, ptr<const char> path) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_shm_open(Thread *thread, ptr<const char> path,
+                                     sint flags, mode_t mode) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_shm_unlink(Thread *thread, ptr<const char> path) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_umtx.cpp b/orbis-kernel/src/sys/sys_umtx.cpp
index 2afd71409..f9290da73 100644
--- a/orbis-kernel/src/sys/sys_umtx.cpp
+++ b/orbis-kernel/src/sys/sys_umtx.cpp
@@ -1,8 +1,15 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys__umtx_lock(Thread *thread, ptr<struct umtx> umtx) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys__umtx_unlock(Thread *thread, ptr<struct umtx> umtx) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys__umtx_op(Thread *thread, ptr<void> obj, sint op, ulong val, ptr<void> uaddr1, ptr<void> uaddr2) {
+orbis::SysResult orbis::sys__umtx_lock(Thread *thread, ptr<struct umtx> umtx) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys__umtx_unlock(Thread *thread,
+                                         ptr<struct umtx> umtx) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys__umtx_op(Thread *thread, ptr<void> obj, sint op,
+                                     ulong val, ptr<void> uaddr1,
+                                     ptr<void> uaddr2) {
   std::printf("TODO: sys__umtx_op\n");
   return {};
 }
diff --git a/orbis-kernel/src/sys/sys_uuid.cpp b/orbis-kernel/src/sys/sys_uuid.cpp
index c55196515..f0a247661 100644
--- a/orbis-kernel/src/sys/sys_uuid.cpp
+++ b/orbis-kernel/src/sys/sys_uuid.cpp
@@ -1,3 +1,6 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_uuidgen(Thread *thread, ptr<struct uuid> store, sint count) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_uuidgen(Thread *thread, ptr<struct uuid> store,
+                                    sint count) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_vfs.cpp b/orbis-kernel/src/sys/sys_vfs.cpp
index 7f3f167b7..f27b97bbd 100644
--- a/orbis-kernel/src/sys/sys_vfs.cpp
+++ b/orbis-kernel/src/sys/sys_vfs.cpp
@@ -2,14 +2,33 @@
 #include "utils/Logs.hpp"
 
 orbis::SysResult orbis::sys_sync(Thread *thread) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_quotactl(Thread *thread, ptr<char> path, sint cmd, sint uid, caddr_t arg) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_statfs(Thread *thread, ptr<char> path, ptr<struct statfs> buf) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_fstatfs(Thread *thread, sint fd, ptr<struct statfs> buf) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_getfsstat(Thread *thread, ptr<struct statfs> buf, slong bufsize, sint flags) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_fchdir(Thread *thread, sint fd) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_chdir(Thread *thread, ptr<char> path) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_chroot(Thread *thread, ptr<char> path) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_open(Thread *thread, ptr<char> path, sint flags, sint mode) {
+orbis::SysResult orbis::sys_quotactl(Thread *thread, ptr<char> path, sint cmd,
+                                     sint uid, caddr_t arg) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_statfs(Thread *thread, ptr<char> path,
+                                   ptr<struct statfs> buf) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_fstatfs(Thread *thread, sint fd,
+                                    ptr<struct statfs> buf) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_getfsstat(Thread *thread, ptr<struct statfs> buf,
+                                      slong bufsize, sint flags) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_fchdir(Thread *thread, sint fd) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_chdir(Thread *thread, ptr<char> path) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_chroot(Thread *thread, ptr<char> path) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_open(Thread *thread, ptr<char> path, sint flags,
+                                 sint mode) {
   ORBIS_LOG_NOTICE("sys_open", path, flags, mode);
   if (auto open = thread->tproc->ops->open) {
     return open(thread, path, flags, mode);
@@ -17,77 +36,240 @@ orbis::SysResult orbis::sys_open(Thread *thread, ptr<char> path, sint flags, sin
 
   return ErrorCode::NOSYS;
 }
-orbis::SysResult orbis::sys_openat(Thread *thread, sint fd, ptr<char> path, sint flag, mode_t mode) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_mknod(Thread *thread, ptr<char> path, sint mode, sint dev) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_mknodat(Thread *thread, sint fd, ptr<char> path, mode_t mode, dev_t dev) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_mkfifo(Thread *thread, ptr<char> path, sint mode) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_mkfifoat(Thread *thread, sint fd, ptr<char> path, mode_t mode) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_link(Thread *thread, ptr<char> path, ptr<char> link) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_linkat(Thread *thread, sint fd1, ptr<char> path1, sint fd2, ptr<char> path2, sint flag) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_symlink(Thread *thread, ptr<char> path, ptr<char> link) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_symlinkat(Thread *thread, ptr<char> path1, sint fd, ptr<char> path2) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_undelete(Thread *thread, ptr<char> path) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_unlink(Thread *thread, ptr<char> path) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_unlinkat(Thread *thread, sint fd, ptr<char> path, sint flag) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_lseek(Thread *thread, sint fd, off_t offset, sint whence) {
+orbis::SysResult orbis::sys_openat(Thread *thread, sint fd, ptr<char> path,
+                                   sint flag, mode_t mode) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_mknod(Thread *thread, ptr<char> path, sint mode,
+                                  sint dev) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_mknodat(Thread *thread, sint fd, ptr<char> path,
+                                    mode_t mode, dev_t dev) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_mkfifo(Thread *thread, ptr<char> path, sint mode) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_mkfifoat(Thread *thread, sint fd, ptr<char> path,
+                                     mode_t mode) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_link(Thread *thread, ptr<char> path,
+                                 ptr<char> link) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_linkat(Thread *thread, sint fd1, ptr<char> path1,
+                                   sint fd2, ptr<char> path2, sint flag) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_symlink(Thread *thread, ptr<char> path,
+                                    ptr<char> link) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_symlinkat(Thread *thread, ptr<char> path1, sint fd,
+                                      ptr<char> path2) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_undelete(Thread *thread, ptr<char> path) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_unlink(Thread *thread, ptr<char> path) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_unlinkat(Thread *thread, sint fd, ptr<char> path,
+                                     sint flag) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_lseek(Thread *thread, sint fd, off_t offset,
+                                  sint whence) {
   if (auto lseek = thread->tproc->ops->lseek) {
     return lseek(thread, fd, offset, whence);
   }
   return ErrorCode::NOSYS;
 }
-orbis::SysResult orbis::sys_freebsd6_lseek(Thread *thread, sint fd, sint, off_t offset, sint whence) {
+orbis::SysResult orbis::sys_freebsd6_lseek(Thread *thread, sint fd, sint,
+                                           off_t offset, sint whence) {
   return sys_lseek(thread, fd, offset, whence);
 }
-orbis::SysResult orbis::sys_access(Thread *thread, ptr<char> path, sint flags) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_faccessat(Thread *thread, sint fd, ptr<char> path, sint mode, sint flag) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_eaccess(Thread *thread, ptr<char> path, sint flags) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_stat(Thread *thread, ptr<char> path, ptr<struct stat> ub) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_fstatat(Thread *thread, sint fd, ptr<char> path, ptr<struct stat> buf, sint flag) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_lstat(Thread *thread, ptr<char> path, ptr<struct stat> ub) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_nstat(Thread *thread, ptr<char> path, ptr<struct nstat> ub) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_nlstat(Thread *thread, ptr<char> path, ptr<struct nstat> ub) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_pathconf(Thread *thread, ptr<char> path, sint name) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_lpathconf(Thread *thread, ptr<char> path, sint name) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_readlink(Thread *thread, ptr<char> path, ptr<char> buf, size_t count) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_readlinkat(Thread *thread, sint fd, ptr<char> path, ptr<char> buf, size_t bufsize) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_chflags(Thread *thread, ptr<char> path, sint flags) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_lchflags(Thread *thread, ptr<const char> path, sint flags) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_fchflags(Thread *thread, sint fd, sint flags) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_chmod(Thread *thread, ptr<char> path, sint mode) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_fchmodat(Thread *thread, sint fd, ptr<char> path, mode_t mode, sint flag) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_lchmod(Thread *thread, ptr<char> path, mode_t mode) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_fchmod(Thread *thread, sint fd, sint mode) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_chown(Thread *thread, ptr<char> path, sint uid, sint gid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_fchownat(Thread *thread, sint fd, ptr<char> path, uid_t uid, gid_t gid, sint flag) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_lchown(Thread *thread, ptr<char> path, sint uid, sint gid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_fchown(Thread *thread, sint fd, sint uid, sint gid) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_utimes(Thread *thread, ptr<char> path, ptr<struct timeval> tptr) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_futimesat(Thread *thread, sint fd, ptr<char> path, ptr<struct timeval> times) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_lutimes(Thread *thread, ptr<char> path, ptr<struct timeval> tptr) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_futimes(Thread *thread, sint fd, ptr<struct timeval> tptr) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_truncate(Thread *thread, ptr<char> path, off_t length) {
+orbis::SysResult orbis::sys_access(Thread *thread, ptr<char> path, sint flags) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_faccessat(Thread *thread, sint fd, ptr<char> path,
+                                      sint mode, sint flag) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_eaccess(Thread *thread, ptr<char> path,
+                                    sint flags) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_stat(Thread *thread, ptr<char> path,
+                                 ptr<struct stat> ub) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_fstatat(Thread *thread, sint fd, ptr<char> path,
+                                    ptr<struct stat> buf, sint flag) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_lstat(Thread *thread, ptr<char> path,
+                                  ptr<struct stat> ub) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_nstat(Thread *thread, ptr<char> path,
+                                  ptr<struct nstat> ub) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_nlstat(Thread *thread, ptr<char> path,
+                                   ptr<struct nstat> ub) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_pathconf(Thread *thread, ptr<char> path,
+                                     sint name) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_lpathconf(Thread *thread, ptr<char> path,
+                                      sint name) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_readlink(Thread *thread, ptr<char> path,
+                                     ptr<char> buf, size_t count) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_readlinkat(Thread *thread, sint fd, ptr<char> path,
+                                       ptr<char> buf, size_t bufsize) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_chflags(Thread *thread, ptr<char> path,
+                                    sint flags) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_lchflags(Thread *thread, ptr<const char> path,
+                                     sint flags) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_fchflags(Thread *thread, sint fd, sint flags) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_chmod(Thread *thread, ptr<char> path, sint mode) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_fchmodat(Thread *thread, sint fd, ptr<char> path,
+                                     mode_t mode, sint flag) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_lchmod(Thread *thread, ptr<char> path,
+                                   mode_t mode) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_fchmod(Thread *thread, sint fd, sint mode) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_chown(Thread *thread, ptr<char> path, sint uid,
+                                  sint gid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_fchownat(Thread *thread, sint fd, ptr<char> path,
+                                     uid_t uid, gid_t gid, sint flag) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_lchown(Thread *thread, ptr<char> path, sint uid,
+                                   sint gid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_fchown(Thread *thread, sint fd, sint uid,
+                                   sint gid) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_utimes(Thread *thread, ptr<char> path,
+                                   ptr<struct timeval> tptr) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_futimesat(Thread *thread, sint fd, ptr<char> path,
+                                      ptr<struct timeval> times) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_lutimes(Thread *thread, ptr<char> path,
+                                    ptr<struct timeval> tptr) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_futimes(Thread *thread, sint fd,
+                                    ptr<struct timeval> tptr) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_truncate(Thread *thread, ptr<char> path,
+                                     off_t length) {
   if (auto truncate = thread->tproc->ops->truncate) {
     return truncate(thread, path, length);
   }
   return ErrorCode::NOSYS;
 }
-orbis::SysResult orbis::sys_freebsd6_truncate(Thread *thread, ptr<char> path, sint, off_t length) {
+orbis::SysResult orbis::sys_freebsd6_truncate(Thread *thread, ptr<char> path,
+                                              sint, off_t length) {
   return sys_truncate(thread, path, length);
 }
-orbis::SysResult orbis::sys_fsync(Thread *thread, sint fd) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_rename(Thread *thread, ptr<char> from, ptr<char> to) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_renameat(Thread *thread, sint oldfd, ptr<char> old, sint newfd, ptr<char> new_) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_mkdir(Thread *thread, ptr<char> path, sint mode) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_mkdirat(Thread *thread, sint fd, ptr<char> path, mode_t mode) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_rmdir(Thread *thread, ptr<char> path) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_getdirentries(Thread *thread, sint fd, ptr<char> buf, uint count, ptr<slong> basep) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_getdents(Thread *thread, sint fd, ptr<char> buf, size_t count) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_umask(Thread *thread, sint newmask) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_revoke(Thread *thread, ptr<char> path) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_lgetfh(Thread *thread, ptr<char> fname, ptr<struct fhandle> fhp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_getfh(Thread *thread, ptr<char> fname, ptr<struct fhandle> fhp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_fhopen(Thread *thread, ptr<const struct fhandle> u_fhp, sint flags) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_fhstat(Thread *thread, ptr<const struct fhandle> u_fhp, ptr<struct stat> sb) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_fhstatfs(Thread *thread, ptr<const struct fhandle> u_fhp, ptr<struct statfs> buf) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_posix_fallocate(Thread *thread, sint fd, off_t offset, off_t len) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_posix_fadvise(Thread *thread, sint fd, off_t offset, off_t len, sint advice) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_fsync(Thread *thread, sint fd) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_rename(Thread *thread, ptr<char> from,
+                                   ptr<char> to) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_renameat(Thread *thread, sint oldfd, ptr<char> old,
+                                     sint newfd, ptr<char> new_) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_mkdir(Thread *thread, ptr<char> path, sint mode) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_mkdirat(Thread *thread, sint fd, ptr<char> path,
+                                    mode_t mode) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_rmdir(Thread *thread, ptr<char> path) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_getdirentries(Thread *thread, sint fd,
+                                          ptr<char> buf, uint count,
+                                          ptr<slong> basep) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_getdents(Thread *thread, sint fd, ptr<char> buf,
+                                     size_t count) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_umask(Thread *thread, sint newmask) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_revoke(Thread *thread, ptr<char> path) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_lgetfh(Thread *thread, ptr<char> fname,
+                                   ptr<struct fhandle> fhp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_getfh(Thread *thread, ptr<char> fname,
+                                  ptr<struct fhandle> fhp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult
+orbis::sys_fhopen(Thread *thread, ptr<const struct fhandle> u_fhp, sint flags) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_fhstat(Thread *thread,
+                                   ptr<const struct fhandle> u_fhp,
+                                   ptr<struct stat> sb) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_fhstatfs(Thread *thread,
+                                     ptr<const struct fhandle> u_fhp,
+                                     ptr<struct statfs> buf) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_posix_fallocate(Thread *thread, sint fd,
+                                            off_t offset, off_t len) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_posix_fadvise(Thread *thread, sint fd, off_t offset,
+                                          off_t len, sint advice) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_vfs_acl.cpp b/orbis-kernel/src/sys/sys_vfs_acl.cpp
index 1d1e3f3e0..9f61dbe34 100644
--- a/orbis-kernel/src/sys/sys_vfs_acl.cpp
+++ b/orbis-kernel/src/sys/sys_vfs_acl.cpp
@@ -1,14 +1,61 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys___acl_get_file(Thread *thread, ptr<char> path, acl_type_t type, ptr<struct acl> aclp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys___acl_get_link(Thread *thread, ptr<const char> path, acl_type_t type, ptr<struct acl> aclp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys___acl_set_file(Thread *thread, ptr<char> path, acl_type_t type, ptr<struct acl> aclp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys___acl_set_link(Thread *thread, ptr<const char> path, acl_type_t type, ptr<struct acl> aclp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys___acl_get_fd(Thread *thread, sint filedes, acl_type_t type, ptr<struct acl> aclp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys___acl_set_fd(Thread *thread, sint filedes, acl_type_t type, ptr<struct acl> aclp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys___acl_delete_link(Thread *thread, ptr<const char> path, acl_type_t type) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys___acl_delete_file(Thread *thread, ptr<char> path, acl_type_t type) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys___acl_delete_fd(Thread *thread, sint filedes, acl_type_t type) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys___acl_aclcheck_file(Thread *thread, ptr<char> path, acl_type_t type, ptr<struct acl> aclp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys___acl_aclcheck_link(Thread *thread, ptr<const char> path, acl_type_t type, ptr<struct acl> aclp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys___acl_aclcheck_fd(Thread *thread, sint filedes, acl_type_t type, ptr<struct acl> aclp) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys___acl_get_file(Thread *thread, ptr<char> path,
+                                           acl_type_t type,
+                                           ptr<struct acl> aclp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys___acl_get_link(Thread *thread, ptr<const char> path,
+                                           acl_type_t type,
+                                           ptr<struct acl> aclp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys___acl_set_file(Thread *thread, ptr<char> path,
+                                           acl_type_t type,
+                                           ptr<struct acl> aclp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys___acl_set_link(Thread *thread, ptr<const char> path,
+                                           acl_type_t type,
+                                           ptr<struct acl> aclp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys___acl_get_fd(Thread *thread, sint filedes,
+                                         acl_type_t type,
+                                         ptr<struct acl> aclp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys___acl_set_fd(Thread *thread, sint filedes,
+                                         acl_type_t type,
+                                         ptr<struct acl> aclp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys___acl_delete_link(Thread *thread,
+                                              ptr<const char> path,
+                                              acl_type_t type) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys___acl_delete_file(Thread *thread, ptr<char> path,
+                                              acl_type_t type) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys___acl_delete_fd(Thread *thread, sint filedes,
+                                            acl_type_t type) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys___acl_aclcheck_file(Thread *thread, ptr<char> path,
+                                                acl_type_t type,
+                                                ptr<struct acl> aclp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys___acl_aclcheck_link(Thread *thread,
+                                                ptr<const char> path,
+                                                acl_type_t type,
+                                                ptr<struct acl> aclp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys___acl_aclcheck_fd(Thread *thread, sint filedes,
+                                              acl_type_t type,
+                                              ptr<struct acl> aclp) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_vfs_aio.cpp b/orbis-kernel/src/sys/sys_vfs_aio.cpp
index 31325b7ab..b8bc7e260 100644
--- a/orbis-kernel/src/sys/sys_vfs_aio.cpp
+++ b/orbis-kernel/src/sys/sys_vfs_aio.cpp
@@ -1,15 +1,53 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_aio_return(Thread *thread, ptr<struct aiocb> aiocbp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_aio_suspend(Thread *thread, ptr<struct aiocb> aiocbp, sint nent, ptr<const struct timespec> timeout) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_aio_cancel(Thread *thread, sint fd, ptr<struct aiocb> aiocbp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_aio_error(Thread *thread, ptr<struct aiocb> aiocbp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_oaio_read(Thread *thread, ptr<struct aiocb> aiocbp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_aio_read(Thread *thread, ptr<struct aiocb> aiocbp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_oaio_write(Thread *thread, ptr<struct aiocb> aiocbp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_aio_write(Thread *thread, ptr<struct aiocb> aiocbp) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_olio_listio(Thread *thread, sint mode, ptr<cptr<struct aiocb>> acb_list, sint nent, ptr<struct osigevent> sig) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_lio_listio(Thread *thread, sint mode, ptr<cptr<struct aiocb>> aiocbp, sint nent, ptr<struct sigevent> sig) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_aio_waitcomplete(Thread *thread, ptr<ptr<struct aiocb>> aiocbp, ptr<struct timespec> timeout) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_aio_fsync(Thread *thread, sint op, ptr<struct aiocb> aiocbp) { return ErrorCode::NOSYS; }
-
+orbis::SysResult orbis::sys_aio_return(Thread *thread,
+                                       ptr<struct aiocb> aiocbp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_aio_suspend(Thread *thread,
+                                        ptr<struct aiocb> aiocbp, sint nent,
+                                        ptr<const struct timespec> timeout) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_aio_cancel(Thread *thread, sint fd,
+                                       ptr<struct aiocb> aiocbp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_aio_error(Thread *thread,
+                                      ptr<struct aiocb> aiocbp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_oaio_read(Thread *thread,
+                                      ptr<struct aiocb> aiocbp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_aio_read(Thread *thread, ptr<struct aiocb> aiocbp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_oaio_write(Thread *thread,
+                                       ptr<struct aiocb> aiocbp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_aio_write(Thread *thread,
+                                      ptr<struct aiocb> aiocbp) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_olio_listio(Thread *thread, sint mode,
+                                        ptr<cptr<struct aiocb>> acb_list,
+                                        sint nent, ptr<struct osigevent> sig) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_lio_listio(Thread *thread, sint mode,
+                                       ptr<cptr<struct aiocb>> aiocbp,
+                                       sint nent, ptr<struct sigevent> sig) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_aio_waitcomplete(Thread *thread,
+                                             ptr<ptr<struct aiocb>> aiocbp,
+                                             ptr<struct timespec> timeout) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_aio_fsync(Thread *thread, sint op,
+                                      ptr<struct aiocb> aiocbp) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_vfs_cache.cpp b/orbis-kernel/src/sys/sys_vfs_cache.cpp
index ae0877913..b4aa4a711 100644
--- a/orbis-kernel/src/sys/sys_vfs_cache.cpp
+++ b/orbis-kernel/src/sys/sys_vfs_cache.cpp
@@ -1,3 +1,6 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys___getcwd(Thread *thread, ptr<char> buf, uint buflen) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys___getcwd(Thread *thread, ptr<char> buf,
+                                     uint buflen) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_vfs_extattr.cpp b/orbis-kernel/src/sys/sys_vfs_extattr.cpp
index 72d8d0eab..460e28a61 100644
--- a/orbis-kernel/src/sys/sys_vfs_extattr.cpp
+++ b/orbis-kernel/src/sys/sys_vfs_extattr.cpp
@@ -1,15 +1,79 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_extattrctl(Thread *thread, ptr<char> path, char cmd, ptr<const char> filename, sint attrnamespace, ptr<const char> attrname) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_extattr_set_fd(Thread *thread, sint fd, sint attrnamespace, ptr<const char> attrname, ptr<void> data, size_t nbytes) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_extattr_set_file(Thread *thread, ptr<char> path, sint attrnamespace, ptr<const char> filename, ptr<void> data, size_t nbytes) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_extattr_set_link(Thread *thread, ptr<const char> path, sint attrnamespace, ptr<const char> attrname, ptr<void> data, size_t nbytes) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_extattr_get_fd(Thread *thread, sint fd, sint attrnamespace, ptr<const char> attrname, ptr<void> data, size_t nbytes) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_extattr_get_file(Thread *thread, ptr<char> path, sint attrnamespace, ptr<const char> filename, ptr<void> data, size_t nbytes) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_extattr_get_link(Thread *thread, ptr<const char> path, sint attrnamespace, ptr<const char> attrname, ptr<void> data, size_t nbytes) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_extattr_delete_fd(Thread *thread, sint fd, sint attrnamespace, ptr<const char> attrname) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_extattr_delete_file(Thread *thread, ptr<char> path, sint attrnamespace, ptr<const char> attrname) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_extattr_delete_link(Thread *thread, ptr<const char> path, sint attrnamespace, ptr<const char> attrname) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_extattr_list_fd(Thread *thread, sint fd, sint attrnamespace, ptr<void> data, size_t nbytes) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_extattr_list_file(Thread *thread, ptr<const char> path, sint attrnamespace, ptr<void> data, size_t nbytes) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_extattr_list_link(Thread *thread, ptr<const char> path, sint attrnamespace, ptr<void> data, size_t nbytes) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_extattrctl(Thread *thread, ptr<char> path, char cmd,
+                                       ptr<const char> filename,
+                                       sint attrnamespace,
+                                       ptr<const char> attrname) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_extattr_set_fd(Thread *thread, sint fd,
+                                           sint attrnamespace,
+                                           ptr<const char> attrname,
+                                           ptr<void> data, size_t nbytes) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_extattr_set_file(Thread *thread, ptr<char> path,
+                                             sint attrnamespace,
+                                             ptr<const char> filename,
+                                             ptr<void> data, size_t nbytes) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_extattr_set_link(Thread *thread,
+                                             ptr<const char> path,
+                                             sint attrnamespace,
+                                             ptr<const char> attrname,
+                                             ptr<void> data, size_t nbytes) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_extattr_get_fd(Thread *thread, sint fd,
+                                           sint attrnamespace,
+                                           ptr<const char> attrname,
+                                           ptr<void> data, size_t nbytes) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_extattr_get_file(Thread *thread, ptr<char> path,
+                                             sint attrnamespace,
+                                             ptr<const char> filename,
+                                             ptr<void> data, size_t nbytes) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_extattr_get_link(Thread *thread,
+                                             ptr<const char> path,
+                                             sint attrnamespace,
+                                             ptr<const char> attrname,
+                                             ptr<void> data, size_t nbytes) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_extattr_delete_fd(Thread *thread, sint fd,
+                                              sint attrnamespace,
+                                              ptr<const char> attrname) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_extattr_delete_file(Thread *thread, ptr<char> path,
+                                                sint attrnamespace,
+                                                ptr<const char> attrname) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_extattr_delete_link(Thread *thread,
+                                                ptr<const char> path,
+                                                sint attrnamespace,
+                                                ptr<const char> attrname) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_extattr_list_fd(Thread *thread, sint fd,
+                                            sint attrnamespace, ptr<void> data,
+                                            size_t nbytes) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_extattr_list_file(Thread *thread,
+                                              ptr<const char> path,
+                                              sint attrnamespace,
+                                              ptr<void> data, size_t nbytes) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_extattr_list_link(Thread *thread,
+                                              ptr<const char> path,
+                                              sint attrnamespace,
+                                              ptr<void> data, size_t nbytes) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_vfs_mount.cpp b/orbis-kernel/src/sys/sys_vfs_mount.cpp
index 188160524..fdfe684ff 100644
--- a/orbis-kernel/src/sys/sys_vfs_mount.cpp
+++ b/orbis-kernel/src/sys/sys_vfs_mount.cpp
@@ -1,5 +1,14 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_mount(Thread *thread, ptr<char> type, ptr<char> path, sint flags, caddr_t data) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_unmount(Thread *thread, ptr<char> path, sint flags) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_nmount(Thread *thread, ptr<struct iovec> iovp, uint iovcnt, sint flags) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_mount(Thread *thread, ptr<char> type,
+                                  ptr<char> path, sint flags, caddr_t data) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_unmount(Thread *thread, ptr<char> path,
+                                    sint flags) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_nmount(Thread *thread, ptr<struct iovec> iovp,
+                                   uint iovcnt, sint flags) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sys/sys_vm_mmap.cpp b/orbis-kernel/src/sys/sys_vm_mmap.cpp
index 950a4ee44..40fb1e697 100644
--- a/orbis-kernel/src/sys/sys_vm_mmap.cpp
+++ b/orbis-kernel/src/sys/sys_vm_mmap.cpp
@@ -93,7 +93,7 @@ orbis::SysResult orbis::sys_munlockall(Thread *thread) {
 }
 orbis::SysResult orbis::sys_munlock(Thread *thread, ptr<const void> addr,
                                     size_t len) {
-   if (auto impl = thread->tproc->ops->munlock) {
+  if (auto impl = thread->tproc->ops->munlock) {
     return impl(thread, addr, len);
   }
 
diff --git a/orbis-kernel/src/sys/sys_vm_unix.cpp b/orbis-kernel/src/sys/sys_vm_unix.cpp
index 160316b04..88a3a599b 100644
--- a/orbis-kernel/src/sys/sys_vm_unix.cpp
+++ b/orbis-kernel/src/sys/sys_vm_unix.cpp
@@ -1,4 +1,8 @@
 #include "sys/sysproto.hpp"
 
-orbis::SysResult orbis::sys_obreak(Thread *thread, ptr<char> nsize) { return ErrorCode::NOSYS; }
-orbis::SysResult orbis::sys_ovadvise(Thread *thread, sint anom) { return ErrorCode::NOSYS; }
+orbis::SysResult orbis::sys_obreak(Thread *thread, ptr<char> nsize) {
+  return ErrorCode::NOSYS;
+}
+orbis::SysResult orbis::sys_ovadvise(Thread *thread, sint anom) {
+  return ErrorCode::NOSYS;
+}
diff --git a/orbis-kernel/src/sysvec.cpp b/orbis-kernel/src/sysvec.cpp
index 00d615875..7adf640a6 100644
--- a/orbis-kernel/src/sysvec.cpp
+++ b/orbis-kernel/src/sysvec.cpp
@@ -1,18 +1,18 @@
 #include "sys/syscall.hpp"
-#include "sys/sysproto.hpp"
 #include "sys/sysentry.hpp"
+#include "sys/sysproto.hpp"
 #include <unordered_map>
 
 enum { PSL_C = 0x1 };
 
 void orbis::syscall_entry(Thread *thread) {
   uint64_t regstbl[] = {
-    readRegister(thread->context, RegisterId::rdi),
-    readRegister(thread->context, RegisterId::rsi),
-    readRegister(thread->context, RegisterId::rdx),
-    readRegister(thread->context, RegisterId::r10),
-    readRegister(thread->context, RegisterId::r8),
-    readRegister(thread->context, RegisterId::r9),
+      readRegister(thread->context, RegisterId::rdi),
+      readRegister(thread->context, RegisterId::rsi),
+      readRegister(thread->context, RegisterId::rdx),
+      readRegister(thread->context, RegisterId::r10),
+      readRegister(thread->context, RegisterId::r8),
+      readRegister(thread->context, RegisterId::r9),
   };
 
   uint64_t *regsptr = regstbl;
@@ -42,8 +42,11 @@ void orbis::syscall_entry(Thread *thread) {
         std::abort();
       }
 
-      error = int(uread(args + regcnt, ptr<void>(readRegister(thread->context, RegisterId::rsp) + sizeof(uint64_t)),
-                        (sysent.narg - regcnt) * sizeof(uint64_t)));
+      error =
+          int(uread(args + regcnt,
+                    ptr<void>(readRegister(thread->context, RegisterId::rsp) +
+                              sizeof(uint64_t)),
+                    (sysent.narg - regcnt) * sizeof(uint64_t)));
     }
 
     if (error == 0) {
@@ -79,8 +82,7 @@ namespace detail {
 template <auto Fn> struct WrapImpl;
 
 template <typename... Args, SysResult (*Fn)(Thread *, Args...)>
-  requires(sizeof...(Args) < 8)
-struct WrapImpl<Fn> {
+requires(sizeof...(Args) < 8) struct WrapImpl<Fn> {
   constexpr sysent operator()() {
     sysent result;
     result.narg = sizeof...(Args);
@@ -106,578 +108,597 @@ template <auto Fn> constexpr auto wrap() -> decltype(detail::WrapImpl<Fn>()()) {
   return detail::WrapImpl<Fn>()();
 }
 
-static const std::unordered_map<SysResult (*)(Thread *, uint64_t *), const char *> gImplToName = {
-  {wrap<nosys>().call, "nosys"},
-  {wrap<sys_exit>().call, "sys_exit"},
-  {wrap<sys_fork>().call, "sys_fork"},
-  {wrap<sys_read>().call, "sys_read"},
-  {wrap<sys_write>().call, "sys_write"},
-  {wrap<sys_open>().call, "sys_open"},
-  {wrap<sys_close>().call, "sys_close"},
-  {wrap<sys_wait4>().call, "sys_wait4"},
-  {wrap<sys_link>().call, "sys_link"},
-  {wrap<sys_unlink>().call, "sys_unlink"},
-  {wrap<sys_chdir>().call, "sys_chdir"},
-  {wrap<sys_fchdir>().call, "sys_fchdir"},
-  {wrap<sys_mknod>().call, "sys_mknod"},
-  {wrap<sys_chmod>().call, "sys_chmod"},
-  {wrap<sys_chown>().call, "sys_chown"},
-  {wrap<sys_obreak>().call, "sys_obreak"},
-  {wrap<sys_getpid>().call, "sys_getpid"},
-  {wrap<sys_mount>().call, "sys_mount"},
-  {wrap<sys_unmount>().call, "sys_unmount"},
-  {wrap<sys_setuid>().call, "sys_setuid"},
-  {wrap<sys_getuid>().call, "sys_getuid"},
-  {wrap<sys_geteuid>().call, "sys_geteuid"},
-  {wrap<sys_ptrace>().call, "sys_ptrace"},
-  {wrap<sys_recvmsg>().call, "sys_recvmsg"},
-  {wrap<sys_sendmsg>().call, "sys_sendmsg"},
-  {wrap<sys_recvfrom>().call, "sys_recvfrom"},
-  {wrap<sys_accept>().call, "sys_accept"},
-  {wrap<sys_getpeername>().call, "sys_getpeername"},
-  {wrap<sys_getsockname>().call, "sys_getsockname"},
-  {wrap<sys_access>().call, "sys_access"},
-  {wrap<sys_chflags>().call, "sys_chflags"},
-  {wrap<sys_fchflags>().call, "sys_fchflags"},
-  {wrap<sys_sync>().call, "sys_sync"},
-  {wrap<sys_kill>().call, "sys_kill"},
-  {wrap<sys_getppid>().call, "sys_getppid"},
-  {wrap<sys_dup>().call, "sys_dup"},
-  {wrap<sys_pipe>().call, "sys_pipe"},
-  {wrap<sys_getegid>().call, "sys_getegid"},
-  {wrap<sys_profil>().call, "sys_profil"},
-  {wrap<sys_ktrace>().call, "sys_ktrace"},
-  {wrap<sys_getgid>().call, "sys_getgid"},
-  {wrap<sys_getlogin>().call, "sys_getlogin"},
-  {wrap<sys_setlogin>().call, "sys_setlogin"},
-  {wrap<sys_acct>().call, "sys_acct"},
-  {wrap<sys_sigaltstack>().call, "sys_sigaltstack"},
-  {wrap<sys_ioctl>().call, "sys_ioctl"},
-  {wrap<sys_reboot>().call, "sys_reboot"},
-  {wrap<sys_revoke>().call, "sys_revoke"},
-  {wrap<sys_symlink>().call, "sys_symlink"},
-  {wrap<sys_readlink>().call, "sys_readlink"},
-  {wrap<sys_execve>().call, "sys_execve"},
-  {wrap<sys_umask>().call, "sys_umask"},
-  {wrap<sys_chroot>().call, "sys_chroot"},
-  {wrap<sys_msync>().call, "sys_msync"},
-  {wrap<sys_vfork>().call, "sys_vfork"},
-  {wrap<sys_sbrk>().call, "sys_sbrk"},
-  {wrap<sys_sstk>().call, "sys_sstk"},
-  {wrap<sys_ovadvise>().call, "sys_ovadvise"},
-  {wrap<sys_munmap>().call, "sys_munmap"},
-  {wrap<sys_mprotect>().call, "sys_mprotect"},
-  {wrap<sys_madvise>().call, "sys_madvise"},
-  {wrap<sys_mincore>().call, "sys_mincore"},
-  {wrap<sys_getgroups>().call, "sys_getgroups"},
-  {wrap<sys_setgroups>().call, "sys_setgroups"},
-  {wrap<sys_getpgrp>().call, "sys_getpgrp"},
-  {wrap<sys_setpgid>().call, "sys_setpgid"},
-  {wrap<sys_setitimer>().call, "sys_setitimer"},
-  {wrap<sys_swapon>().call, "sys_swapon"},
-  {wrap<sys_getitimer>().call, "sys_getitimer"},
-  {wrap<sys_getdtablesize>().call, "sys_getdtablesize"},
-  {wrap<sys_dup2>().call, "sys_dup2"},
-  {wrap<sys_fcntl>().call, "sys_fcntl"},
-  {wrap<sys_select>().call, "sys_select"},
-  {wrap<sys_fsync>().call, "sys_fsync"},
-  {wrap<sys_setpriority>().call, "sys_setpriority"},
-  {wrap<sys_socket>().call, "sys_socket"},
-  {wrap<sys_connect>().call, "sys_connect"},
-  {wrap<sys_getpriority>().call, "sys_getpriority"},
-  {wrap<sys_bind>().call, "sys_bind"},
-  {wrap<sys_setsockopt>().call, "sys_setsockopt"},
-  {wrap<sys_listen>().call, "sys_listen"},
-  {wrap<sys_gettimeofday>().call, "sys_gettimeofday"},
-  {wrap<sys_getrusage>().call, "sys_getrusage"},
-  {wrap<sys_getsockopt>().call, "sys_getsockopt"},
-  {wrap<sys_readv>().call, "sys_readv"},
-  {wrap<sys_writev>().call, "sys_writev"},
-  {wrap<sys_settimeofday>().call, "sys_settimeofday"},
-  {wrap<sys_fchown>().call, "sys_fchown"},
-  {wrap<sys_fchmod>().call, "sys_fchmod"},
-  {wrap<sys_setreuid>().call, "sys_setreuid"},
-  {wrap<sys_setregid>().call, "sys_setregid"},
-  {wrap<sys_rename>().call, "sys_rename"},
-  {wrap<sys_flock>().call, "sys_flock"},
-  {wrap<sys_mkfifo>().call, "sys_mkfifo"},
-  {wrap<sys_sendto>().call, "sys_sendto"},
-  {wrap<sys_shutdown>().call, "sys_shutdown"},
-  {wrap<sys_socketpair>().call, "sys_socketpair"},
-  {wrap<sys_mkdir>().call, "sys_mkdir"},
-  {wrap<sys_rmdir>().call, "sys_rmdir"},
-  {wrap<sys_utimes>().call, "sys_utimes"},
-  {wrap<sys_adjtime>().call, "sys_adjtime"},
-  {wrap<sys_setsid>().call, "sys_setsid"},
-  {wrap<sys_quotactl>().call, "sys_quotactl"},
-  {wrap<sys_nlm_syscall>().call, "sys_nlm_syscall"},
-  {wrap<sys_nfssvc>().call, "sys_nfssvc"},
-  {wrap<sys_lgetfh>().call, "sys_lgetfh"},
-  {wrap<sys_getfh>().call, "sys_getfh"},
-  {wrap<sys_sysarch>().call, "sys_sysarch"},
-  {wrap<sys_rtprio>().call, "sys_rtprio"},
-  {wrap<sys_semsys>().call, "sys_semsys"},
-  {wrap<sys_msgsys>().call, "sys_msgsys"},
-  {wrap<sys_shmsys>().call, "sys_shmsys"},
-  {wrap<sys_freebsd6_pread>().call, "sys_freebsd6_pread"},
-  {wrap<sys_freebsd6_pwrite>().call, "sys_freebsd6_pwrite"},
-  {wrap<sys_setfib>().call, "sys_setfib"},
-  {wrap<sys_ntp_adjtime>().call, "sys_ntp_adjtime"},
-  {wrap<sys_setgid>().call, "sys_setgid"},
-  {wrap<sys_setegid>().call, "sys_setegid"},
-  {wrap<sys_seteuid>().call, "sys_seteuid"},
-  {wrap<sys_stat>().call, "sys_stat"},
-  {wrap<sys_fstat>().call, "sys_fstat"},
-  {wrap<sys_lstat>().call, "sys_lstat"},
-  {wrap<sys_pathconf>().call, "sys_pathconf"},
-  {wrap<sys_fpathconf>().call, "sys_fpathconf"},
-  {wrap<sys_getrlimit>().call, "sys_getrlimit"},
-  {wrap<sys_setrlimit>().call, "sys_setrlimit"},
-  {wrap<sys_getdirentries>().call, "sys_getdirentries"},
-  {wrap<sys_freebsd6_mmap>().call, "sys_freebsd6_mmap"},
-  {wrap<sys_freebsd6_lseek>().call, "sys_freebsd6_lseek"},
-  {wrap<sys_freebsd6_truncate>().call, "sys_freebsd6_truncate"},
-  {wrap<sys_freebsd6_ftruncate>().call, "sys_freebsd6_ftruncate"},
-  {wrap<sys___sysctl>().call, "sys___sysctl"},
-  {wrap<sys_mlock>().call, "sys_mlock"},
-  {wrap<sys_munlock>().call, "sys_munlock"},
-  {wrap<sys_undelete>().call, "sys_undelete"},
-  {wrap<sys_futimes>().call, "sys_futimes"},
-  {wrap<sys_getpgid>().call, "sys_getpgid"},
-  {wrap<sys_poll>().call, "sys_poll"},
-  {wrap<sys_semget>().call, "sys_semget"},
-  {wrap<sys_semop>().call, "sys_semop"},
-  {wrap<sys_msgget>().call, "sys_msgget"},
-  {wrap<sys_msgsnd>().call, "sys_msgsnd"},
-  {wrap<sys_msgrcv>().call, "sys_msgrcv"},
-  {wrap<sys_shmat>().call, "sys_shmat"},
-  {wrap<sys_shmdt>().call, "sys_shmdt"},
-  {wrap<sys_shmget>().call, "sys_shmget"},
-  {wrap<sys_clock_gettime>().call, "sys_clock_gettime"},
-  {wrap<sys_clock_settime>().call, "sys_clock_settime"},
-  {wrap<sys_clock_getres>().call, "sys_clock_getres"},
-  {wrap<sys_ktimer_create>().call, "sys_ktimer_create"},
-  {wrap<sys_ktimer_delete>().call, "sys_ktimer_delete"},
-  {wrap<sys_ktimer_settime>().call, "sys_ktimer_settime"},
-  {wrap<sys_ktimer_gettime>().call, "sys_ktimer_gettime"},
-  {wrap<sys_ktimer_getoverrun>().call, "sys_ktimer_getoverrun"},
-  {wrap<sys_nanosleep>().call, "sys_nanosleep"},
-  {wrap<sys_ntp_gettime>().call, "sys_ntp_gettime"},
-  {wrap<sys_minherit>().call, "sys_minherit"},
-  {wrap<sys_rfork>().call, "sys_rfork"},
-  {wrap<sys_openbsd_poll>().call, "sys_openbsd_poll"},
-  {wrap<sys_issetugid>().call, "sys_issetugid"},
-  {wrap<sys_lchown>().call, "sys_lchown"},
-  {wrap<sys_aio_read>().call, "sys_aio_read"},
-  {wrap<sys_aio_write>().call, "sys_aio_write"},
-  {wrap<sys_lio_listio>().call, "sys_lio_listio"},
-  {wrap<sys_getdents>().call, "sys_getdents"},
-  {wrap<sys_lchmod>().call, "sys_lchmod"},
-  {wrap<sys_lutimes>().call, "sys_lutimes"},
-  {wrap<sys_nstat>().call, "sys_nstat"},
-  {wrap<sys_nfstat>().call, "sys_nfstat"},
-  {wrap<sys_nlstat>().call, "sys_nlstat"},
-  {wrap<sys_preadv>().call, "sys_preadv"},
-  {wrap<sys_pwritev>().call, "sys_pwritev"},
-  {wrap<sys_fhopen>().call, "sys_fhopen"},
-  {wrap<sys_fhstat>().call, "sys_fhstat"},
-  {wrap<sys_modnext>().call, "sys_modnext"},
-  {wrap<sys_modstat>().call, "sys_modstat"},
-  {wrap<sys_modfnext>().call, "sys_modfnext"},
-  {wrap<sys_modfind>().call, "sys_modfind"},
-  {wrap<sys_kldload>().call, "sys_kldload"},
-  {wrap<sys_kldunload>().call, "sys_kldunload"},
-  {wrap<sys_kldfind>().call, "sys_kldfind"},
-  {wrap<sys_kldnext>().call, "sys_kldnext"},
-  {wrap<sys_kldstat>().call, "sys_kldstat"},
-  {wrap<sys_kldfirstmod>().call, "sys_kldfirstmod"},
-  {wrap<sys_getsid>().call, "sys_getsid"},
-  {wrap<sys_setresuid>().call, "sys_setresuid"},
-  {wrap<sys_setresgid>().call, "sys_setresgid"},
-  {wrap<sys_aio_return>().call, "sys_aio_return"},
-  {wrap<sys_aio_suspend>().call, "sys_aio_suspend"},
-  {wrap<sys_aio_cancel>().call, "sys_aio_cancel"},
-  {wrap<sys_aio_error>().call, "sys_aio_error"},
-  {wrap<sys_oaio_read>().call, "sys_oaio_read"},
-  {wrap<sys_oaio_write>().call, "sys_oaio_write"},
-  {wrap<sys_olio_listio>().call, "sys_olio_listio"},
-  {wrap<sys_yield>().call, "sys_yield"},
-  {wrap<sys_mlockall>().call, "sys_mlockall"},
-  {wrap<sys_munlockall>().call, "sys_munlockall"},
-  {wrap<sys___getcwd>().call, "sys___getcwd"},
-  {wrap<sys_sched_setparam>().call, "sys_sched_setparam"},
-  {wrap<sys_sched_getparam>().call, "sys_sched_getparam"},
-  {wrap<sys_sched_setscheduler>().call, "sys_sched_setscheduler"},
-  {wrap<sys_sched_getscheduler>().call, "sys_sched_getscheduler"},
-  {wrap<sys_sched_yield>().call, "sys_sched_yield"},
-  {wrap<sys_sched_get_priority_max>().call, "sys_sched_get_priority_max"},
-  {wrap<sys_sched_get_priority_min>().call, "sys_sched_get_priority_min"},
-  {wrap<sys_sched_rr_get_interval>().call, "sys_sched_rr_get_interval"},
-  {wrap<sys_utrace>().call, "sys_utrace"},
-  {wrap<sys_kldsym>().call, "sys_kldsym"},
-  {wrap<sys_jail>().call, "sys_jail"},
-  {wrap<sys_nnpfs_syscall>().call, "sys_nnpfs_syscall"},
-  {wrap<sys_sigprocmask>().call, "sys_sigprocmask"},
-  {wrap<sys_sigsuspend>().call, "sys_sigsuspend"},
-  {wrap<sys_sigpending>().call, "sys_sigpending"},
-  {wrap<sys_sigtimedwait>().call, "sys_sigtimedwait"},
-  {wrap<sys_sigwaitinfo>().call, "sys_sigwaitinfo"},
-  {wrap<sys___acl_get_file>().call, "sys___acl_get_file"},
-  {wrap<sys___acl_set_file>().call, "sys___acl_set_file"},
-  {wrap<sys___acl_get_fd>().call, "sys___acl_get_fd"},
-  {wrap<sys___acl_set_fd>().call, "sys___acl_set_fd"},
-  {wrap<sys___acl_delete_file>().call, "sys___acl_delete_file"},
-  {wrap<sys___acl_delete_fd>().call, "sys___acl_delete_fd"},
-  {wrap<sys___acl_aclcheck_file>().call, "sys___acl_aclcheck_file"},
-  {wrap<sys___acl_aclcheck_fd>().call, "sys___acl_aclcheck_fd"},
-  {wrap<sys_extattrctl>().call, "sys_extattrctl"},
-  {wrap<sys_extattr_set_file>().call, "sys_extattr_set_file"},
-  {wrap<sys_extattr_get_file>().call, "sys_extattr_get_file"},
-  {wrap<sys_extattr_delete_file>().call, "sys_extattr_delete_file"},
-  {wrap<sys_aio_waitcomplete>().call, "sys_aio_waitcomplete"},
-  {wrap<sys_getresuid>().call, "sys_getresuid"},
-  {wrap<sys_getresgid>().call, "sys_getresgid"},
-  {wrap<sys_kqueue>().call, "sys_kqueue"},
-  {wrap<sys_kevent>().call, "sys_kevent"},
-  {wrap<sys_extattr_set_fd>().call, "sys_extattr_set_fd"},
-  {wrap<sys_extattr_get_fd>().call, "sys_extattr_get_fd"},
-  {wrap<sys_extattr_delete_fd>().call, "sys_extattr_delete_fd"},
-  {wrap<sys___setugid>().call, "sys___setugid"},
-  {wrap<sys_eaccess>().call, "sys_eaccess"},
-  {wrap<sys_afs3_syscall>().call, "sys_afs3_syscall"},
-  {wrap<sys_nmount>().call, "sys_nmount"},
-  {wrap<sys___mac_get_proc>().call, "sys___mac_get_proc"},
-  {wrap<sys___mac_set_proc>().call, "sys___mac_set_proc"},
-  {wrap<sys___mac_get_fd>().call, "sys___mac_get_fd"},
-  {wrap<sys___mac_get_file>().call, "sys___mac_get_file"},
-  {wrap<sys___mac_set_fd>().call, "sys___mac_set_fd"},
-  {wrap<sys___mac_set_file>().call, "sys___mac_set_file"},
-  {wrap<sys_kenv>().call, "sys_kenv"},
-  {wrap<sys_lchflags>().call, "sys_lchflags"},
-  {wrap<sys_uuidgen>().call, "sys_uuidgen"},
-  {wrap<sys_sendfile>().call, "sys_sendfile"},
-  {wrap<sys_mac_syscall>().call, "sys_mac_syscall"},
-  {wrap<sys_getfsstat>().call, "sys_getfsstat"},
-  {wrap<sys_statfs>().call, "sys_statfs"},
-  {wrap<sys_fstatfs>().call, "sys_fstatfs"},
-  {wrap<sys_fhstatfs>().call, "sys_fhstatfs"},
-  {wrap<sys_ksem_close>().call, "sys_ksem_close"},
-  {wrap<sys_ksem_post>().call, "sys_ksem_post"},
-  {wrap<sys_ksem_wait>().call, "sys_ksem_wait"},
-  {wrap<sys_ksem_trywait>().call, "sys_ksem_trywait"},
-  {wrap<sys_ksem_init>().call, "sys_ksem_init"},
-  {wrap<sys_ksem_open>().call, "sys_ksem_open"},
-  {wrap<sys_ksem_unlink>().call, "sys_ksem_unlink"},
-  {wrap<sys_ksem_getvalue>().call, "sys_ksem_getvalue"},
-  {wrap<sys_ksem_destroy>().call, "sys_ksem_destroy"},
-  {wrap<sys___mac_get_pid>().call, "sys___mac_get_pid"},
-  {wrap<sys___mac_get_link>().call, "sys___mac_get_link"},
-  {wrap<sys___mac_set_link>().call, "sys___mac_set_link"},
-  {wrap<sys_extattr_set_link>().call, "sys_extattr_set_link"},
-  {wrap<sys_extattr_get_link>().call, "sys_extattr_get_link"},
-  {wrap<sys_extattr_delete_link>().call, "sys_extattr_delete_link"},
-  {wrap<sys___mac_execve>().call, "sys___mac_execve"},
-  {wrap<sys_sigaction>().call, "sys_sigaction"},
-  {wrap<sys_sigreturn>().call, "sys_sigreturn"},
-  {wrap<sys_getcontext>().call, "sys_getcontext"},
-  {wrap<sys_setcontext>().call, "sys_setcontext"},
-  {wrap<sys_swapcontext>().call, "sys_swapcontext"},
-  {wrap<sys_swapoff>().call, "sys_swapoff"},
-  {wrap<sys___acl_get_link>().call, "sys___acl_get_link"},
-  {wrap<sys___acl_set_link>().call, "sys___acl_set_link"},
-  {wrap<sys___acl_delete_link>().call, "sys___acl_delete_link"},
-  {wrap<sys___acl_aclcheck_link>().call, "sys___acl_aclcheck_link"},
-  {wrap<sys_sigwait>().call, "sys_sigwait"},
-  {wrap<sys_thr_create>().call, "sys_thr_create"},
-  {wrap<sys_thr_exit>().call, "sys_thr_exit"},
-  {wrap<sys_thr_self>().call, "sys_thr_self"},
-  {wrap<sys_thr_kill>().call, "sys_thr_kill"},
-  {wrap<sys__umtx_lock>().call, "sys__umtx_lock"},
-  {wrap<sys__umtx_unlock>().call, "sys__umtx_unlock"},
-  {wrap<sys_jail_attach>().call, "sys_jail_attach"},
-  {wrap<sys_extattr_list_fd>().call, "sys_extattr_list_fd"},
-  {wrap<sys_extattr_list_file>().call, "sys_extattr_list_file"},
-  {wrap<sys_extattr_list_link>().call, "sys_extattr_list_link"},
-  {wrap<sys_ksem_timedwait>().call, "sys_ksem_timedwait"},
-  {wrap<sys_thr_suspend>().call, "sys_thr_suspend"},
-  {wrap<sys_thr_wake>().call, "sys_thr_wake"},
-  {wrap<sys_kldunloadf>().call, "sys_kldunloadf"},
-  {wrap<sys_audit>().call, "sys_audit"},
-  {wrap<sys_auditon>().call, "sys_auditon"},
-  {wrap<sys_getauid>().call, "sys_getauid"},
-  {wrap<sys_setauid>().call, "sys_setauid"},
-  {wrap<sys_getaudit>().call, "sys_getaudit"},
-  {wrap<sys_setaudit>().call, "sys_setaudit"},
-  {wrap<sys_getaudit_addr>().call, "sys_getaudit_addr"},
-  {wrap<sys_setaudit_addr>().call, "sys_setaudit_addr"},
-  {wrap<sys_auditctl>().call, "sys_auditctl"},
-  {wrap<sys__umtx_op>().call, "sys__umtx_op"},
-  {wrap<sys_thr_new>().call, "sys_thr_new"},
-  {wrap<sys_sigqueue>().call, "sys_sigqueue"},
-  {wrap<sys_kmq_open>().call, "sys_kmq_open"},
-  {wrap<sys_kmq_setattr>().call, "sys_kmq_setattr"},
-  {wrap<sys_kmq_timedreceive>().call, "sys_kmq_timedreceive"},
-  {wrap<sys_kmq_timedsend>().call, "sys_kmq_timedsend"},
-  {wrap<sys_kmq_notify>().call, "sys_kmq_notify"},
-  {wrap<sys_kmq_unlink>().call, "sys_kmq_unlink"},
-  {wrap<sys_abort2>().call, "sys_abort2"},
-  {wrap<sys_thr_set_name>().call, "sys_thr_set_name"},
-  {wrap<sys_aio_fsync>().call, "sys_aio_fsync"},
-  {wrap<sys_rtprio_thread>().call, "sys_rtprio_thread"},
-  {wrap<sys_sctp_peeloff>().call, "sys_sctp_peeloff"},
-  {wrap<sys_sctp_generic_sendmsg>().call, "sys_sctp_generic_sendmsg"},
-  {wrap<sys_sctp_generic_sendmsg_iov>().call, "sys_sctp_generic_sendmsg_iov"},
-  {wrap<sys_sctp_generic_recvmsg>().call, "sys_sctp_generic_recvmsg"},
-  {wrap<sys_pread>().call, "sys_pread"},
-  {wrap<sys_pwrite>().call, "sys_pwrite"},
-  {wrap<sys_mmap>().call, "sys_mmap"},
-  {wrap<sys_lseek>().call, "sys_lseek"},
-  {wrap<sys_truncate>().call, "sys_truncate"},
-  {wrap<sys_ftruncate>().call, "sys_ftruncate"},
-  {wrap<sys_thr_kill2>().call, "sys_thr_kill2"},
-  {wrap<sys_shm_open>().call, "sys_shm_open"},
-  {wrap<sys_shm_unlink>().call, "sys_shm_unlink"},
-  {wrap<sys_cpuset>().call, "sys_cpuset"},
-  {wrap<sys_cpuset_setid>().call, "sys_cpuset_setid"},
-  {wrap<sys_cpuset_getid>().call, "sys_cpuset_getid"},
-  {wrap<sys_cpuset_getaffinity>().call, "sys_cpuset_getaffinity"},
-  {wrap<sys_cpuset_setaffinity>().call, "sys_cpuset_setaffinity"},
-  {wrap<sys_faccessat>().call, "sys_faccessat"},
-  {wrap<sys_fchmodat>().call, "sys_fchmodat"},
-  {wrap<sys_fchownat>().call, "sys_fchownat"},
-  {wrap<sys_fexecve>().call, "sys_fexecve"},
-  {wrap<sys_fstatat>().call, "sys_fstatat"},
-  {wrap<sys_futimesat>().call, "sys_futimesat"},
-  {wrap<sys_linkat>().call, "sys_linkat"},
-  {wrap<sys_mkdirat>().call, "sys_mkdirat"},
-  {wrap<sys_mkfifoat>().call, "sys_mkfifoat"},
-  {wrap<sys_mknodat>().call, "sys_mknodat"},
-  {wrap<sys_openat>().call, "sys_openat"},
-  {wrap<sys_readlinkat>().call, "sys_readlinkat"},
-  {wrap<sys_renameat>().call, "sys_renameat"},
-  {wrap<sys_symlinkat>().call, "sys_symlinkat"},
-  {wrap<sys_unlinkat>().call, "sys_unlinkat"},
-  {wrap<sys_posix_openpt>().call, "sys_posix_openpt"},
-  {wrap<sys_gssd_syscall>().call, "sys_gssd_syscall"},
-  {wrap<sys_jail_get>().call, "sys_jail_get"},
-  {wrap<sys_jail_set>().call, "sys_jail_set"},
-  {wrap<sys_jail_remove>().call, "sys_jail_remove"},
-  {wrap<sys_closefrom>().call, "sys_closefrom"},
-  {wrap<sys___semctl>().call, "sys___semctl"},
-  {wrap<sys_msgctl>().call, "sys_msgctl"},
-  {wrap<sys_shmctl>().call, "sys_shmctl"},
-  {wrap<sys_lpathconf>().call, "sys_lpathconf"},
-  {wrap<sys_cap_new>().call, "sys_cap_new"},
-  {wrap<sys_cap_getrights>().call, "sys_cap_getrights"},
-  {wrap<sys_cap_enter>().call, "sys_cap_enter"},
-  {wrap<sys_cap_getmode>().call, "sys_cap_getmode"},
-  {wrap<sys_pdfork>().call, "sys_pdfork"},
-  {wrap<sys_pdkill>().call, "sys_pdkill"},
-  {wrap<sys_pdgetpid>().call, "sys_pdgetpid"},
-  {wrap<sys_pselect>().call, "sys_pselect"},
-  {wrap<sys_getloginclass>().call, "sys_getloginclass"},
-  {wrap<sys_setloginclass>().call, "sys_setloginclass"},
-  {wrap<sys_rctl_get_racct>().call, "sys_rctl_get_racct"},
-  {wrap<sys_rctl_get_rules>().call, "sys_rctl_get_rules"},
-  {wrap<sys_rctl_get_limits>().call, "sys_rctl_get_limits"},
-  {wrap<sys_rctl_add_rule>().call, "sys_rctl_add_rule"},
-  {wrap<sys_rctl_remove_rule>().call, "sys_rctl_remove_rule"},
-  {wrap<sys_posix_fallocate>().call, "sys_posix_fallocate"},
-  {wrap<sys_posix_fadvise>().call, "sys_posix_fadvise"},
-  {wrap<sys_netcontrol>().call, "sys_netcontrol"},
-  {wrap<sys_netabort>().call, "sys_netabort"},
-  {wrap<sys_netgetsockinfo>().call, "sys_netgetsockinfo"},
-  {wrap<sys_socketex>().call, "sys_socketex"},
-  {wrap<sys_socketclose>().call, "sys_socketclose"},
-  {wrap<sys_netgetiflist>().call, "sys_netgetiflist"},
-  {wrap<sys_kqueueex>().call, "sys_kqueueex"},
-  {wrap<sys_mtypeprotect>().call, "sys_mtypeprotect"},
-  {wrap<sys_regmgr_call>().call, "sys_regmgr_call"},
-  {wrap<sys_jitshm_create>().call, "sys_jitshm_create"},
-  {wrap<sys_jitshm_alias>().call, "sys_jitshm_alias"},
-  {wrap<sys_dl_get_list>().call, "sys_dl_get_list"},
-  {wrap<sys_dl_get_info>().call, "sys_dl_get_info"},
-  {wrap<sys_dl_notify_event>().call, "sys_dl_notify_event"},
-  {wrap<sys_evf_create>().call, "sys_evf_create"},
-  {wrap<sys_evf_delete>().call, "sys_evf_delete"},
-  {wrap<sys_evf_open>().call, "sys_evf_open"},
-  {wrap<sys_evf_close>().call, "sys_evf_close"},
-  {wrap<sys_evf_wait>().call, "sys_evf_wait"},
-  {wrap<sys_evf_trywait>().call, "sys_evf_trywait"},
-  {wrap<sys_evf_set>().call, "sys_evf_set"},
-  {wrap<sys_evf_clear>().call, "sys_evf_clear"},
-  {wrap<sys_evf_cancel>().call, "sys_evf_cancel"},
-  {wrap<sys_query_memory_protection>().call, "sys_query_memory_protection"},
-  {wrap<sys_batch_map>().call, "sys_batch_map"},
-  {wrap<sys_osem_create>().call, "sys_osem_create"},
-  {wrap<sys_osem_delete>().call, "sys_osem_delete"},
-  {wrap<sys_osem_open>().call, "sys_osem_open"},
-  {wrap<sys_osem_close>().call, "sys_osem_close"},
-  {wrap<sys_osem_wait>().call, "sys_osem_wait"},
-  {wrap<sys_osem_trywait>().call, "sys_osem_trywait"},
-  {wrap<sys_osem_post>().call, "sys_osem_post"},
-  {wrap<sys_osem_cancel>().call, "sys_osem_cancel"},
-  {wrap<sys_namedobj_create>().call, "sys_namedobj_create"},
-  {wrap<sys_namedobj_delete>().call, "sys_namedobj_delete"},
-  {wrap<sys_set_vm_container>().call, "sys_set_vm_container"},
-  {wrap<sys_debug_init>().call, "sys_debug_init"},
-  {wrap<sys_suspend_process>().call, "sys_suspend_process"},
-  {wrap<sys_resume_process>().call, "sys_resume_process"},
-  {wrap<sys_opmc_enable>().call, "sys_opmc_enable"},
-  {wrap<sys_opmc_disable>().call, "sys_opmc_disable"},
-  {wrap<sys_opmc_set_ctl>().call, "sys_opmc_set_ctl"},
-  {wrap<sys_opmc_set_ctr>().call, "sys_opmc_set_ctr"},
-  {wrap<sys_opmc_get_ctr>().call, "sys_opmc_get_ctr"},
-  {wrap<sys_budget_create>().call, "sys_budget_create"},
-  {wrap<sys_budget_delete>().call, "sys_budget_delete"},
-  {wrap<sys_budget_get>().call, "sys_budget_get"},
-  {wrap<sys_budget_set>().call, "sys_budget_set"},
-  {wrap<sys_virtual_query>().call, "sys_virtual_query"},
-  {wrap<sys_mdbg_call>().call, "sys_mdbg_call"},
-  {wrap<sys_obs_sblock_create>().call, "sys_obs_sblock_create"},
-  {wrap<sys_obs_sblock_delete>().call, "sys_obs_sblock_delete"},
-  {wrap<sys_obs_sblock_enter>().call, "sys_obs_sblock_enter"},
-  {wrap<sys_obs_sblock_exit>().call, "sys_obs_sblock_exit"},
-  {wrap<sys_obs_sblock_xenter>().call, "sys_obs_sblock_xenter"},
-  {wrap<sys_obs_sblock_xexit>().call, "sys_obs_sblock_xexit"},
-  {wrap<sys_obs_eport_create>().call, "sys_obs_eport_create"},
-  {wrap<sys_obs_eport_delete>().call, "sys_obs_eport_delete"},
-  {wrap<sys_obs_eport_trigger>().call, "sys_obs_eport_trigger"},
-  {wrap<sys_obs_eport_open>().call, "sys_obs_eport_open"},
-  {wrap<sys_obs_eport_close>().call, "sys_obs_eport_close"},
-  {wrap<sys_is_in_sandbox>().call, "sys_is_in_sandbox"},
-  {wrap<sys_dmem_container>().call, "sys_dmem_container"},
-  {wrap<sys_get_authinfo>().call, "sys_get_authinfo"},
-  {wrap<sys_mname>().call, "sys_mname"},
-  {wrap<sys_dynlib_dlopen>().call, "sys_dynlib_dlopen"},
-  {wrap<sys_dynlib_dlclose>().call, "sys_dynlib_dlclose"},
-  {wrap<sys_dynlib_dlsym>().call, "sys_dynlib_dlsym"},
-  {wrap<sys_dynlib_get_list>().call, "sys_dynlib_get_list"},
-  {wrap<sys_dynlib_get_info>().call, "sys_dynlib_get_info"},
-  {wrap<sys_dynlib_load_prx>().call, "sys_dynlib_load_prx"},
-  {wrap<sys_dynlib_unload_prx>().call, "sys_dynlib_unload_prx"},
-  {wrap<sys_dynlib_do_copy_relocations>().call, "sys_dynlib_do_copy_relocations"},
-  {wrap<sys_dynlib_prepare_dlclose>().call, "sys_dynlib_prepare_dlclose"},
-  {wrap<sys_dynlib_get_proc_param>().call, "sys_dynlib_get_proc_param"},
-  {wrap<sys_dynlib_process_needed_and_relocate>().call, "sys_dynlib_process_needed_and_relocate"},
-  {wrap<sys_sandbox_path>().call, "sys_sandbox_path"},
-  {wrap<sys_mdbg_service>().call, "sys_mdbg_service"},
-  {wrap<sys_randomized_path>().call, "sys_randomized_path"},
-  {wrap<sys_rdup>().call, "sys_rdup"},
-  {wrap<sys_dl_get_metadata>().call, "sys_dl_get_metadata"},
-  {wrap<sys_workaround8849>().call, "sys_workaround8849"},
-  {wrap<sys_is_development_mode>().call, "sys_is_development_mode"},
-  {wrap<sys_get_self_auth_info>().call, "sys_get_self_auth_info"},
-  {wrap<sys_dynlib_get_info_ex>().call, "sys_dynlib_get_info_ex"},
-  {wrap<sys_budget_getid>().call, "sys_budget_getid"},
-  {wrap<sys_budget_get_ptype>().call, "sys_budget_get_ptype"},
-  {wrap<sys_get_paging_stats_of_all_threads>().call, "sys_get_paging_stats_of_all_threads"},
-  {wrap<sys_get_proc_type_info>().call, "sys_get_proc_type_info"},
-  {wrap<sys_get_resident_count>().call, "sys_get_resident_count"},
-  {wrap<sys_prepare_to_suspend_process>().call, "sys_prepare_to_suspend_process"},
-  {wrap<sys_get_resident_fmem_count>().call, "sys_get_resident_fmem_count"},
-  {wrap<sys_thr_get_name>().call, "sys_thr_get_name"},
-  {wrap<sys_set_gpo>().call, "sys_set_gpo"},
-  {wrap<sys_get_paging_stats_of_all_objects>().call, "sys_get_paging_stats_of_all_objects"},
-  {wrap<sys_test_debug_rwmem>().call, "sys_test_debug_rwmem"},
-  {wrap<sys_free_stack>().call, "sys_free_stack"},
-  {wrap<sys_suspend_system>().call, "sys_suspend_system"},
-  {wrap<sys_ipmimgr_call>().call, "sys_ipmimgr_call"},
-  {wrap<sys_get_gpo>().call, "sys_get_gpo"},
-  {wrap<sys_get_vm_map_timestamp>().call, "sys_get_vm_map_timestamp"},
-  {wrap<sys_opmc_set_hw>().call, "sys_opmc_set_hw"},
-  {wrap<sys_opmc_get_hw>().call, "sys_opmc_get_hw"},
-  {wrap<sys_get_cpu_usage_all>().call, "sys_get_cpu_usage_all"},
-  {wrap<sys_mmap_dmem>().call, "sys_mmap_dmem"},
-  {wrap<sys_physhm_open>().call, "sys_physhm_open"},
-  {wrap<sys_physhm_unlink>().call, "sys_physhm_unlink"},
-  {wrap<sys_resume_internal_hdd>().call, "sys_resume_internal_hdd"},
-  {wrap<sys_thr_suspend_ucontext>().call, "sys_thr_suspend_ucontext"},
-  {wrap<sys_thr_resume_ucontext>().call, "sys_thr_resume_ucontext"},
-  {wrap<sys_thr_get_ucontext>().call, "sys_thr_get_ucontext"},
-  {wrap<sys_thr_set_ucontext>().call, "sys_thr_set_ucontext"},
-  {wrap<sys_set_timezone_info>().call, "sys_set_timezone_info"},
-  {wrap<sys_set_phys_fmem_limit>().call, "sys_set_phys_fmem_limit"},
-  {wrap<sys_utc_to_localtime>().call, "sys_utc_to_localtime"},
-  {wrap<sys_localtime_to_utc>().call, "sys_localtime_to_utc"},
-  {wrap<sys_set_uevt>().call, "sys_set_uevt"},
-  {wrap<sys_get_cpu_usage_proc>().call, "sys_get_cpu_usage_proc"},
-  {wrap<sys_get_map_statistics>().call, "sys_get_map_statistics"},
-  {wrap<sys_set_chicken_switches>().call, "sys_set_chicken_switches"},
-  {wrap<sys_extend_page_table_pool>().call, "sys_extend_page_table_pool"},
-  {wrap<sys_extend_page_table_pool2>().call, "sys_extend_page_table_pool2"},
-  {wrap<sys_get_kernel_mem_statistics>().call, "sys_get_kernel_mem_statistics"},
-  {wrap<sys_get_sdk_compiled_version>().call, "sys_get_sdk_compiled_version"},
-  {wrap<sys_app_state_change>().call, "sys_app_state_change"},
-  {wrap<sys_dynlib_get_obj_member>().call, "sys_dynlib_get_obj_member"},
-  {wrap<sys_budget_get_ptype_of_budget>().call, "sys_budget_get_ptype_of_budget"},
-  {wrap<sys_prepare_to_resume_process>().call, "sys_prepare_to_resume_process"},
-  {wrap<sys_process_terminate>().call, "sys_process_terminate"},
-  {wrap<sys_blockpool_open>().call, "sys_blockpool_open"},
-  {wrap<sys_blockpool_map>().call, "sys_blockpool_map"},
-  {wrap<sys_blockpool_unmap>().call, "sys_blockpool_unmap"},
-  {wrap<sys_dynlib_get_info_for_libdbg>().call, "sys_dynlib_get_info_for_libdbg"},
-  {wrap<sys_blockpool_batch>().call, "sys_blockpool_batch"},
-  {wrap<sys_fdatasync>().call, "sys_fdatasync"},
-  {wrap<sys_dynlib_get_list2>().call, "sys_dynlib_get_list2"},
-  {wrap<sys_dynlib_get_info2>().call, "sys_dynlib_get_info2"},
-  {wrap<sys_aio_submit>().call, "sys_aio_submit"},
-  {wrap<sys_aio_multi_delete>().call, "sys_aio_multi_delete"},
-  {wrap<sys_aio_multi_wait>().call, "sys_aio_multi_wait"},
-  {wrap<sys_aio_multi_poll>().call, "sys_aio_multi_poll"},
-  {wrap<sys_aio_get_data>().call, "sys_aio_get_data"},
-  {wrap<sys_aio_multi_cancel>().call, "sys_aio_multi_cancel"},
-  {wrap<sys_get_bio_usage_all>().call, "sys_get_bio_usage_all"},
-  {wrap<sys_aio_create>().call, "sys_aio_create"},
-  {wrap<sys_aio_submit_cmd>().call, "sys_aio_submit_cmd"},
-  {wrap<sys_aio_init>().call, "sys_aio_init"},
-  {wrap<sys_get_page_table_stats>().call, "sys_get_page_table_stats"},
-  {wrap<sys_dynlib_get_list_for_libdbg>().call, "sys_dynlib_get_list_for_libdbg"},
-  {wrap<sys_blockpool_move>().call, "sys_blockpool_move"},
-  {wrap<sys_virtual_query_all>().call, "sys_virtual_query_all"},
-  {wrap<sys_reserve_2mb_page>().call, "sys_reserve_2mb_page"},
-  {wrap<sys_cpumode_yield>().call, "sys_cpumode_yield"},
-  {wrap<sys_wait6>().call, "sys_wait6"},
-  {wrap<sys_cap_rights_limit>().call, "sys_cap_rights_limit"},
-  {wrap<sys_cap_ioctls_limit>().call, "sys_cap_ioctls_limit"},
-  {wrap<sys_cap_ioctls_get>().call, "sys_cap_ioctls_get"},
-  {wrap<sys_cap_fcntls_limit>().call, "sys_cap_fcntls_limit"},
-  {wrap<sys_cap_fcntls_get>().call, "sys_cap_fcntls_get"},
-  {wrap<sys_bindat>().call, "sys_bindat"},
-  {wrap<sys_connectat>().call, "sys_connectat"},
-  {wrap<sys_chflagsat>().call, "sys_chflagsat"},
-  {wrap<sys_accept4>().call, "sys_accept4"},
-  {wrap<sys_pipe2>().call, "sys_pipe2"},
-  {wrap<sys_aio_mlock>().call, "sys_aio_mlock"},
-  {wrap<sys_procctl>().call, "sys_procctl"},
-  {wrap<sys_ppoll>().call, "sys_ppoll"},
-  {wrap<sys_futimens>().call, "sys_futimens"},
-  {wrap<sys_utimensat>().call, "sys_utimensat"},
-  {wrap<sys_numa_getaffinity>().call, "sys_numa_getaffinity"},
-  {wrap<sys_numa_setaffinity>().call, "sys_numa_setaffinity"},
-  {wrap<sys_apr_submit>().call, "sys_apr_submit"},
-  {wrap<sys_apr_resolve>().call, "sys_apr_resolve"},
-  {wrap<sys_apr_stat>().call, "sys_apr_stat"},
-  {wrap<sys_apr_wait>().call, "sys_apr_wait"},
-  {wrap<sys_apr_ctrl>().call, "sys_apr_ctrl"},
-  {wrap<sys_get_phys_page_size>().call, "sys_get_phys_page_size"},
-  {wrap<sys_begin_app_mount>().call, "sys_begin_app_mount"},
-  {wrap<sys_end_app_mount>().call, "sys_end_app_mount"},
-  {wrap<sys_fsc2h_ctrl>().call, "sys_fsc2h_ctrl"},
-  {wrap<sys_streamwrite>().call, "sys_streamwrite"},
-  {wrap<sys_app_save>().call, "sys_app_save"},
-  {wrap<sys_app_restore>().call, "sys_app_restore"},
-  {wrap<sys_saved_app_delete>().call, "sys_saved_app_delete"},
-  {wrap<sys_get_ppr_sdk_compiled_version>().call, "sys_get_ppr_sdk_compiled_version"},
-  {wrap<sys_notify_app_event>().call, "sys_notify_app_event"},
-  {wrap<sys_ioreq>().call, "sys_ioreq"},
-  {wrap<sys_openintr>().call, "sys_openintr"},
-  {wrap<sys_dl_get_info_2>().call, "sys_dl_get_info_2"},
-  {wrap<sys_acinfo_add>().call, "sys_acinfo_add"},
-  {wrap<sys_acinfo_delete>().call, "sys_acinfo_delete"},
-  {wrap<sys_acinfo_get_all_for_coredump>().call, "sys_acinfo_get_all_for_coredump"},
-  {wrap<sys_ampr_ctrl_debug>().call, "sys_ampr_ctrl_debug"},
-  {wrap<sys_workspace_ctrl>().call, "sys_workspace_ctrl"},
+static const std::unordered_map<SysResult (*)(Thread *, uint64_t *),
+                                const char *>
+    gImplToName = {
+        {wrap<nosys>().call, "nosys"},
+        {wrap<sys_exit>().call, "sys_exit"},
+        {wrap<sys_fork>().call, "sys_fork"},
+        {wrap<sys_read>().call, "sys_read"},
+        {wrap<sys_write>().call, "sys_write"},
+        {wrap<sys_open>().call, "sys_open"},
+        {wrap<sys_close>().call, "sys_close"},
+        {wrap<sys_wait4>().call, "sys_wait4"},
+        {wrap<sys_link>().call, "sys_link"},
+        {wrap<sys_unlink>().call, "sys_unlink"},
+        {wrap<sys_chdir>().call, "sys_chdir"},
+        {wrap<sys_fchdir>().call, "sys_fchdir"},
+        {wrap<sys_mknod>().call, "sys_mknod"},
+        {wrap<sys_chmod>().call, "sys_chmod"},
+        {wrap<sys_chown>().call, "sys_chown"},
+        {wrap<sys_obreak>().call, "sys_obreak"},
+        {wrap<sys_getpid>().call, "sys_getpid"},
+        {wrap<sys_mount>().call, "sys_mount"},
+        {wrap<sys_unmount>().call, "sys_unmount"},
+        {wrap<sys_setuid>().call, "sys_setuid"},
+        {wrap<sys_getuid>().call, "sys_getuid"},
+        {wrap<sys_geteuid>().call, "sys_geteuid"},
+        {wrap<sys_ptrace>().call, "sys_ptrace"},
+        {wrap<sys_recvmsg>().call, "sys_recvmsg"},
+        {wrap<sys_sendmsg>().call, "sys_sendmsg"},
+        {wrap<sys_recvfrom>().call, "sys_recvfrom"},
+        {wrap<sys_accept>().call, "sys_accept"},
+        {wrap<sys_getpeername>().call, "sys_getpeername"},
+        {wrap<sys_getsockname>().call, "sys_getsockname"},
+        {wrap<sys_access>().call, "sys_access"},
+        {wrap<sys_chflags>().call, "sys_chflags"},
+        {wrap<sys_fchflags>().call, "sys_fchflags"},
+        {wrap<sys_sync>().call, "sys_sync"},
+        {wrap<sys_kill>().call, "sys_kill"},
+        {wrap<sys_getppid>().call, "sys_getppid"},
+        {wrap<sys_dup>().call, "sys_dup"},
+        {wrap<sys_pipe>().call, "sys_pipe"},
+        {wrap<sys_getegid>().call, "sys_getegid"},
+        {wrap<sys_profil>().call, "sys_profil"},
+        {wrap<sys_ktrace>().call, "sys_ktrace"},
+        {wrap<sys_getgid>().call, "sys_getgid"},
+        {wrap<sys_getlogin>().call, "sys_getlogin"},
+        {wrap<sys_setlogin>().call, "sys_setlogin"},
+        {wrap<sys_acct>().call, "sys_acct"},
+        {wrap<sys_sigaltstack>().call, "sys_sigaltstack"},
+        {wrap<sys_ioctl>().call, "sys_ioctl"},
+        {wrap<sys_reboot>().call, "sys_reboot"},
+        {wrap<sys_revoke>().call, "sys_revoke"},
+        {wrap<sys_symlink>().call, "sys_symlink"},
+        {wrap<sys_readlink>().call, "sys_readlink"},
+        {wrap<sys_execve>().call, "sys_execve"},
+        {wrap<sys_umask>().call, "sys_umask"},
+        {wrap<sys_chroot>().call, "sys_chroot"},
+        {wrap<sys_msync>().call, "sys_msync"},
+        {wrap<sys_vfork>().call, "sys_vfork"},
+        {wrap<sys_sbrk>().call, "sys_sbrk"},
+        {wrap<sys_sstk>().call, "sys_sstk"},
+        {wrap<sys_ovadvise>().call, "sys_ovadvise"},
+        {wrap<sys_munmap>().call, "sys_munmap"},
+        {wrap<sys_mprotect>().call, "sys_mprotect"},
+        {wrap<sys_madvise>().call, "sys_madvise"},
+        {wrap<sys_mincore>().call, "sys_mincore"},
+        {wrap<sys_getgroups>().call, "sys_getgroups"},
+        {wrap<sys_setgroups>().call, "sys_setgroups"},
+        {wrap<sys_getpgrp>().call, "sys_getpgrp"},
+        {wrap<sys_setpgid>().call, "sys_setpgid"},
+        {wrap<sys_setitimer>().call, "sys_setitimer"},
+        {wrap<sys_swapon>().call, "sys_swapon"},
+        {wrap<sys_getitimer>().call, "sys_getitimer"},
+        {wrap<sys_getdtablesize>().call, "sys_getdtablesize"},
+        {wrap<sys_dup2>().call, "sys_dup2"},
+        {wrap<sys_fcntl>().call, "sys_fcntl"},
+        {wrap<sys_select>().call, "sys_select"},
+        {wrap<sys_fsync>().call, "sys_fsync"},
+        {wrap<sys_setpriority>().call, "sys_setpriority"},
+        {wrap<sys_socket>().call, "sys_socket"},
+        {wrap<sys_connect>().call, "sys_connect"},
+        {wrap<sys_getpriority>().call, "sys_getpriority"},
+        {wrap<sys_bind>().call, "sys_bind"},
+        {wrap<sys_setsockopt>().call, "sys_setsockopt"},
+        {wrap<sys_listen>().call, "sys_listen"},
+        {wrap<sys_gettimeofday>().call, "sys_gettimeofday"},
+        {wrap<sys_getrusage>().call, "sys_getrusage"},
+        {wrap<sys_getsockopt>().call, "sys_getsockopt"},
+        {wrap<sys_readv>().call, "sys_readv"},
+        {wrap<sys_writev>().call, "sys_writev"},
+        {wrap<sys_settimeofday>().call, "sys_settimeofday"},
+        {wrap<sys_fchown>().call, "sys_fchown"},
+        {wrap<sys_fchmod>().call, "sys_fchmod"},
+        {wrap<sys_setreuid>().call, "sys_setreuid"},
+        {wrap<sys_setregid>().call, "sys_setregid"},
+        {wrap<sys_rename>().call, "sys_rename"},
+        {wrap<sys_flock>().call, "sys_flock"},
+        {wrap<sys_mkfifo>().call, "sys_mkfifo"},
+        {wrap<sys_sendto>().call, "sys_sendto"},
+        {wrap<sys_shutdown>().call, "sys_shutdown"},
+        {wrap<sys_socketpair>().call, "sys_socketpair"},
+        {wrap<sys_mkdir>().call, "sys_mkdir"},
+        {wrap<sys_rmdir>().call, "sys_rmdir"},
+        {wrap<sys_utimes>().call, "sys_utimes"},
+        {wrap<sys_adjtime>().call, "sys_adjtime"},
+        {wrap<sys_setsid>().call, "sys_setsid"},
+        {wrap<sys_quotactl>().call, "sys_quotactl"},
+        {wrap<sys_nlm_syscall>().call, "sys_nlm_syscall"},
+        {wrap<sys_nfssvc>().call, "sys_nfssvc"},
+        {wrap<sys_lgetfh>().call, "sys_lgetfh"},
+        {wrap<sys_getfh>().call, "sys_getfh"},
+        {wrap<sys_sysarch>().call, "sys_sysarch"},
+        {wrap<sys_rtprio>().call, "sys_rtprio"},
+        {wrap<sys_semsys>().call, "sys_semsys"},
+        {wrap<sys_msgsys>().call, "sys_msgsys"},
+        {wrap<sys_shmsys>().call, "sys_shmsys"},
+        {wrap<sys_freebsd6_pread>().call, "sys_freebsd6_pread"},
+        {wrap<sys_freebsd6_pwrite>().call, "sys_freebsd6_pwrite"},
+        {wrap<sys_setfib>().call, "sys_setfib"},
+        {wrap<sys_ntp_adjtime>().call, "sys_ntp_adjtime"},
+        {wrap<sys_setgid>().call, "sys_setgid"},
+        {wrap<sys_setegid>().call, "sys_setegid"},
+        {wrap<sys_seteuid>().call, "sys_seteuid"},
+        {wrap<sys_stat>().call, "sys_stat"},
+        {wrap<sys_fstat>().call, "sys_fstat"},
+        {wrap<sys_lstat>().call, "sys_lstat"},
+        {wrap<sys_pathconf>().call, "sys_pathconf"},
+        {wrap<sys_fpathconf>().call, "sys_fpathconf"},
+        {wrap<sys_getrlimit>().call, "sys_getrlimit"},
+        {wrap<sys_setrlimit>().call, "sys_setrlimit"},
+        {wrap<sys_getdirentries>().call, "sys_getdirentries"},
+        {wrap<sys_freebsd6_mmap>().call, "sys_freebsd6_mmap"},
+        {wrap<sys_freebsd6_lseek>().call, "sys_freebsd6_lseek"},
+        {wrap<sys_freebsd6_truncate>().call, "sys_freebsd6_truncate"},
+        {wrap<sys_freebsd6_ftruncate>().call, "sys_freebsd6_ftruncate"},
+        {wrap<sys___sysctl>().call, "sys___sysctl"},
+        {wrap<sys_mlock>().call, "sys_mlock"},
+        {wrap<sys_munlock>().call, "sys_munlock"},
+        {wrap<sys_undelete>().call, "sys_undelete"},
+        {wrap<sys_futimes>().call, "sys_futimes"},
+        {wrap<sys_getpgid>().call, "sys_getpgid"},
+        {wrap<sys_poll>().call, "sys_poll"},
+        {wrap<sys_semget>().call, "sys_semget"},
+        {wrap<sys_semop>().call, "sys_semop"},
+        {wrap<sys_msgget>().call, "sys_msgget"},
+        {wrap<sys_msgsnd>().call, "sys_msgsnd"},
+        {wrap<sys_msgrcv>().call, "sys_msgrcv"},
+        {wrap<sys_shmat>().call, "sys_shmat"},
+        {wrap<sys_shmdt>().call, "sys_shmdt"},
+        {wrap<sys_shmget>().call, "sys_shmget"},
+        {wrap<sys_clock_gettime>().call, "sys_clock_gettime"},
+        {wrap<sys_clock_settime>().call, "sys_clock_settime"},
+        {wrap<sys_clock_getres>().call, "sys_clock_getres"},
+        {wrap<sys_ktimer_create>().call, "sys_ktimer_create"},
+        {wrap<sys_ktimer_delete>().call, "sys_ktimer_delete"},
+        {wrap<sys_ktimer_settime>().call, "sys_ktimer_settime"},
+        {wrap<sys_ktimer_gettime>().call, "sys_ktimer_gettime"},
+        {wrap<sys_ktimer_getoverrun>().call, "sys_ktimer_getoverrun"},
+        {wrap<sys_nanosleep>().call, "sys_nanosleep"},
+        {wrap<sys_ntp_gettime>().call, "sys_ntp_gettime"},
+        {wrap<sys_minherit>().call, "sys_minherit"},
+        {wrap<sys_rfork>().call, "sys_rfork"},
+        {wrap<sys_openbsd_poll>().call, "sys_openbsd_poll"},
+        {wrap<sys_issetugid>().call, "sys_issetugid"},
+        {wrap<sys_lchown>().call, "sys_lchown"},
+        {wrap<sys_aio_read>().call, "sys_aio_read"},
+        {wrap<sys_aio_write>().call, "sys_aio_write"},
+        {wrap<sys_lio_listio>().call, "sys_lio_listio"},
+        {wrap<sys_getdents>().call, "sys_getdents"},
+        {wrap<sys_lchmod>().call, "sys_lchmod"},
+        {wrap<sys_lutimes>().call, "sys_lutimes"},
+        {wrap<sys_nstat>().call, "sys_nstat"},
+        {wrap<sys_nfstat>().call, "sys_nfstat"},
+        {wrap<sys_nlstat>().call, "sys_nlstat"},
+        {wrap<sys_preadv>().call, "sys_preadv"},
+        {wrap<sys_pwritev>().call, "sys_pwritev"},
+        {wrap<sys_fhopen>().call, "sys_fhopen"},
+        {wrap<sys_fhstat>().call, "sys_fhstat"},
+        {wrap<sys_modnext>().call, "sys_modnext"},
+        {wrap<sys_modstat>().call, "sys_modstat"},
+        {wrap<sys_modfnext>().call, "sys_modfnext"},
+        {wrap<sys_modfind>().call, "sys_modfind"},
+        {wrap<sys_kldload>().call, "sys_kldload"},
+        {wrap<sys_kldunload>().call, "sys_kldunload"},
+        {wrap<sys_kldfind>().call, "sys_kldfind"},
+        {wrap<sys_kldnext>().call, "sys_kldnext"},
+        {wrap<sys_kldstat>().call, "sys_kldstat"},
+        {wrap<sys_kldfirstmod>().call, "sys_kldfirstmod"},
+        {wrap<sys_getsid>().call, "sys_getsid"},
+        {wrap<sys_setresuid>().call, "sys_setresuid"},
+        {wrap<sys_setresgid>().call, "sys_setresgid"},
+        {wrap<sys_aio_return>().call, "sys_aio_return"},
+        {wrap<sys_aio_suspend>().call, "sys_aio_suspend"},
+        {wrap<sys_aio_cancel>().call, "sys_aio_cancel"},
+        {wrap<sys_aio_error>().call, "sys_aio_error"},
+        {wrap<sys_oaio_read>().call, "sys_oaio_read"},
+        {wrap<sys_oaio_write>().call, "sys_oaio_write"},
+        {wrap<sys_olio_listio>().call, "sys_olio_listio"},
+        {wrap<sys_yield>().call, "sys_yield"},
+        {wrap<sys_mlockall>().call, "sys_mlockall"},
+        {wrap<sys_munlockall>().call, "sys_munlockall"},
+        {wrap<sys___getcwd>().call, "sys___getcwd"},
+        {wrap<sys_sched_setparam>().call, "sys_sched_setparam"},
+        {wrap<sys_sched_getparam>().call, "sys_sched_getparam"},
+        {wrap<sys_sched_setscheduler>().call, "sys_sched_setscheduler"},
+        {wrap<sys_sched_getscheduler>().call, "sys_sched_getscheduler"},
+        {wrap<sys_sched_yield>().call, "sys_sched_yield"},
+        {wrap<sys_sched_get_priority_max>().call, "sys_sched_get_priority_max"},
+        {wrap<sys_sched_get_priority_min>().call, "sys_sched_get_priority_min"},
+        {wrap<sys_sched_rr_get_interval>().call, "sys_sched_rr_get_interval"},
+        {wrap<sys_utrace>().call, "sys_utrace"},
+        {wrap<sys_kldsym>().call, "sys_kldsym"},
+        {wrap<sys_jail>().call, "sys_jail"},
+        {wrap<sys_nnpfs_syscall>().call, "sys_nnpfs_syscall"},
+        {wrap<sys_sigprocmask>().call, "sys_sigprocmask"},
+        {wrap<sys_sigsuspend>().call, "sys_sigsuspend"},
+        {wrap<sys_sigpending>().call, "sys_sigpending"},
+        {wrap<sys_sigtimedwait>().call, "sys_sigtimedwait"},
+        {wrap<sys_sigwaitinfo>().call, "sys_sigwaitinfo"},
+        {wrap<sys___acl_get_file>().call, "sys___acl_get_file"},
+        {wrap<sys___acl_set_file>().call, "sys___acl_set_file"},
+        {wrap<sys___acl_get_fd>().call, "sys___acl_get_fd"},
+        {wrap<sys___acl_set_fd>().call, "sys___acl_set_fd"},
+        {wrap<sys___acl_delete_file>().call, "sys___acl_delete_file"},
+        {wrap<sys___acl_delete_fd>().call, "sys___acl_delete_fd"},
+        {wrap<sys___acl_aclcheck_file>().call, "sys___acl_aclcheck_file"},
+        {wrap<sys___acl_aclcheck_fd>().call, "sys___acl_aclcheck_fd"},
+        {wrap<sys_extattrctl>().call, "sys_extattrctl"},
+        {wrap<sys_extattr_set_file>().call, "sys_extattr_set_file"},
+        {wrap<sys_extattr_get_file>().call, "sys_extattr_get_file"},
+        {wrap<sys_extattr_delete_file>().call, "sys_extattr_delete_file"},
+        {wrap<sys_aio_waitcomplete>().call, "sys_aio_waitcomplete"},
+        {wrap<sys_getresuid>().call, "sys_getresuid"},
+        {wrap<sys_getresgid>().call, "sys_getresgid"},
+        {wrap<sys_kqueue>().call, "sys_kqueue"},
+        {wrap<sys_kevent>().call, "sys_kevent"},
+        {wrap<sys_extattr_set_fd>().call, "sys_extattr_set_fd"},
+        {wrap<sys_extattr_get_fd>().call, "sys_extattr_get_fd"},
+        {wrap<sys_extattr_delete_fd>().call, "sys_extattr_delete_fd"},
+        {wrap<sys___setugid>().call, "sys___setugid"},
+        {wrap<sys_eaccess>().call, "sys_eaccess"},
+        {wrap<sys_afs3_syscall>().call, "sys_afs3_syscall"},
+        {wrap<sys_nmount>().call, "sys_nmount"},
+        {wrap<sys___mac_get_proc>().call, "sys___mac_get_proc"},
+        {wrap<sys___mac_set_proc>().call, "sys___mac_set_proc"},
+        {wrap<sys___mac_get_fd>().call, "sys___mac_get_fd"},
+        {wrap<sys___mac_get_file>().call, "sys___mac_get_file"},
+        {wrap<sys___mac_set_fd>().call, "sys___mac_set_fd"},
+        {wrap<sys___mac_set_file>().call, "sys___mac_set_file"},
+        {wrap<sys_kenv>().call, "sys_kenv"},
+        {wrap<sys_lchflags>().call, "sys_lchflags"},
+        {wrap<sys_uuidgen>().call, "sys_uuidgen"},
+        {wrap<sys_sendfile>().call, "sys_sendfile"},
+        {wrap<sys_mac_syscall>().call, "sys_mac_syscall"},
+        {wrap<sys_getfsstat>().call, "sys_getfsstat"},
+        {wrap<sys_statfs>().call, "sys_statfs"},
+        {wrap<sys_fstatfs>().call, "sys_fstatfs"},
+        {wrap<sys_fhstatfs>().call, "sys_fhstatfs"},
+        {wrap<sys_ksem_close>().call, "sys_ksem_close"},
+        {wrap<sys_ksem_post>().call, "sys_ksem_post"},
+        {wrap<sys_ksem_wait>().call, "sys_ksem_wait"},
+        {wrap<sys_ksem_trywait>().call, "sys_ksem_trywait"},
+        {wrap<sys_ksem_init>().call, "sys_ksem_init"},
+        {wrap<sys_ksem_open>().call, "sys_ksem_open"},
+        {wrap<sys_ksem_unlink>().call, "sys_ksem_unlink"},
+        {wrap<sys_ksem_getvalue>().call, "sys_ksem_getvalue"},
+        {wrap<sys_ksem_destroy>().call, "sys_ksem_destroy"},
+        {wrap<sys___mac_get_pid>().call, "sys___mac_get_pid"},
+        {wrap<sys___mac_get_link>().call, "sys___mac_get_link"},
+        {wrap<sys___mac_set_link>().call, "sys___mac_set_link"},
+        {wrap<sys_extattr_set_link>().call, "sys_extattr_set_link"},
+        {wrap<sys_extattr_get_link>().call, "sys_extattr_get_link"},
+        {wrap<sys_extattr_delete_link>().call, "sys_extattr_delete_link"},
+        {wrap<sys___mac_execve>().call, "sys___mac_execve"},
+        {wrap<sys_sigaction>().call, "sys_sigaction"},
+        {wrap<sys_sigreturn>().call, "sys_sigreturn"},
+        {wrap<sys_getcontext>().call, "sys_getcontext"},
+        {wrap<sys_setcontext>().call, "sys_setcontext"},
+        {wrap<sys_swapcontext>().call, "sys_swapcontext"},
+        {wrap<sys_swapoff>().call, "sys_swapoff"},
+        {wrap<sys___acl_get_link>().call, "sys___acl_get_link"},
+        {wrap<sys___acl_set_link>().call, "sys___acl_set_link"},
+        {wrap<sys___acl_delete_link>().call, "sys___acl_delete_link"},
+        {wrap<sys___acl_aclcheck_link>().call, "sys___acl_aclcheck_link"},
+        {wrap<sys_sigwait>().call, "sys_sigwait"},
+        {wrap<sys_thr_create>().call, "sys_thr_create"},
+        {wrap<sys_thr_exit>().call, "sys_thr_exit"},
+        {wrap<sys_thr_self>().call, "sys_thr_self"},
+        {wrap<sys_thr_kill>().call, "sys_thr_kill"},
+        {wrap<sys__umtx_lock>().call, "sys__umtx_lock"},
+        {wrap<sys__umtx_unlock>().call, "sys__umtx_unlock"},
+        {wrap<sys_jail_attach>().call, "sys_jail_attach"},
+        {wrap<sys_extattr_list_fd>().call, "sys_extattr_list_fd"},
+        {wrap<sys_extattr_list_file>().call, "sys_extattr_list_file"},
+        {wrap<sys_extattr_list_link>().call, "sys_extattr_list_link"},
+        {wrap<sys_ksem_timedwait>().call, "sys_ksem_timedwait"},
+        {wrap<sys_thr_suspend>().call, "sys_thr_suspend"},
+        {wrap<sys_thr_wake>().call, "sys_thr_wake"},
+        {wrap<sys_kldunloadf>().call, "sys_kldunloadf"},
+        {wrap<sys_audit>().call, "sys_audit"},
+        {wrap<sys_auditon>().call, "sys_auditon"},
+        {wrap<sys_getauid>().call, "sys_getauid"},
+        {wrap<sys_setauid>().call, "sys_setauid"},
+        {wrap<sys_getaudit>().call, "sys_getaudit"},
+        {wrap<sys_setaudit>().call, "sys_setaudit"},
+        {wrap<sys_getaudit_addr>().call, "sys_getaudit_addr"},
+        {wrap<sys_setaudit_addr>().call, "sys_setaudit_addr"},
+        {wrap<sys_auditctl>().call, "sys_auditctl"},
+        {wrap<sys__umtx_op>().call, "sys__umtx_op"},
+        {wrap<sys_thr_new>().call, "sys_thr_new"},
+        {wrap<sys_sigqueue>().call, "sys_sigqueue"},
+        {wrap<sys_kmq_open>().call, "sys_kmq_open"},
+        {wrap<sys_kmq_setattr>().call, "sys_kmq_setattr"},
+        {wrap<sys_kmq_timedreceive>().call, "sys_kmq_timedreceive"},
+        {wrap<sys_kmq_timedsend>().call, "sys_kmq_timedsend"},
+        {wrap<sys_kmq_notify>().call, "sys_kmq_notify"},
+        {wrap<sys_kmq_unlink>().call, "sys_kmq_unlink"},
+        {wrap<sys_abort2>().call, "sys_abort2"},
+        {wrap<sys_thr_set_name>().call, "sys_thr_set_name"},
+        {wrap<sys_aio_fsync>().call, "sys_aio_fsync"},
+        {wrap<sys_rtprio_thread>().call, "sys_rtprio_thread"},
+        {wrap<sys_sctp_peeloff>().call, "sys_sctp_peeloff"},
+        {wrap<sys_sctp_generic_sendmsg>().call, "sys_sctp_generic_sendmsg"},
+        {wrap<sys_sctp_generic_sendmsg_iov>().call,
+         "sys_sctp_generic_sendmsg_iov"},
+        {wrap<sys_sctp_generic_recvmsg>().call, "sys_sctp_generic_recvmsg"},
+        {wrap<sys_pread>().call, "sys_pread"},
+        {wrap<sys_pwrite>().call, "sys_pwrite"},
+        {wrap<sys_mmap>().call, "sys_mmap"},
+        {wrap<sys_lseek>().call, "sys_lseek"},
+        {wrap<sys_truncate>().call, "sys_truncate"},
+        {wrap<sys_ftruncate>().call, "sys_ftruncate"},
+        {wrap<sys_thr_kill2>().call, "sys_thr_kill2"},
+        {wrap<sys_shm_open>().call, "sys_shm_open"},
+        {wrap<sys_shm_unlink>().call, "sys_shm_unlink"},
+        {wrap<sys_cpuset>().call, "sys_cpuset"},
+        {wrap<sys_cpuset_setid>().call, "sys_cpuset_setid"},
+        {wrap<sys_cpuset_getid>().call, "sys_cpuset_getid"},
+        {wrap<sys_cpuset_getaffinity>().call, "sys_cpuset_getaffinity"},
+        {wrap<sys_cpuset_setaffinity>().call, "sys_cpuset_setaffinity"},
+        {wrap<sys_faccessat>().call, "sys_faccessat"},
+        {wrap<sys_fchmodat>().call, "sys_fchmodat"},
+        {wrap<sys_fchownat>().call, "sys_fchownat"},
+        {wrap<sys_fexecve>().call, "sys_fexecve"},
+        {wrap<sys_fstatat>().call, "sys_fstatat"},
+        {wrap<sys_futimesat>().call, "sys_futimesat"},
+        {wrap<sys_linkat>().call, "sys_linkat"},
+        {wrap<sys_mkdirat>().call, "sys_mkdirat"},
+        {wrap<sys_mkfifoat>().call, "sys_mkfifoat"},
+        {wrap<sys_mknodat>().call, "sys_mknodat"},
+        {wrap<sys_openat>().call, "sys_openat"},
+        {wrap<sys_readlinkat>().call, "sys_readlinkat"},
+        {wrap<sys_renameat>().call, "sys_renameat"},
+        {wrap<sys_symlinkat>().call, "sys_symlinkat"},
+        {wrap<sys_unlinkat>().call, "sys_unlinkat"},
+        {wrap<sys_posix_openpt>().call, "sys_posix_openpt"},
+        {wrap<sys_gssd_syscall>().call, "sys_gssd_syscall"},
+        {wrap<sys_jail_get>().call, "sys_jail_get"},
+        {wrap<sys_jail_set>().call, "sys_jail_set"},
+        {wrap<sys_jail_remove>().call, "sys_jail_remove"},
+        {wrap<sys_closefrom>().call, "sys_closefrom"},
+        {wrap<sys___semctl>().call, "sys___semctl"},
+        {wrap<sys_msgctl>().call, "sys_msgctl"},
+        {wrap<sys_shmctl>().call, "sys_shmctl"},
+        {wrap<sys_lpathconf>().call, "sys_lpathconf"},
+        {wrap<sys_cap_new>().call, "sys_cap_new"},
+        {wrap<sys_cap_getrights>().call, "sys_cap_getrights"},
+        {wrap<sys_cap_enter>().call, "sys_cap_enter"},
+        {wrap<sys_cap_getmode>().call, "sys_cap_getmode"},
+        {wrap<sys_pdfork>().call, "sys_pdfork"},
+        {wrap<sys_pdkill>().call, "sys_pdkill"},
+        {wrap<sys_pdgetpid>().call, "sys_pdgetpid"},
+        {wrap<sys_pselect>().call, "sys_pselect"},
+        {wrap<sys_getloginclass>().call, "sys_getloginclass"},
+        {wrap<sys_setloginclass>().call, "sys_setloginclass"},
+        {wrap<sys_rctl_get_racct>().call, "sys_rctl_get_racct"},
+        {wrap<sys_rctl_get_rules>().call, "sys_rctl_get_rules"},
+        {wrap<sys_rctl_get_limits>().call, "sys_rctl_get_limits"},
+        {wrap<sys_rctl_add_rule>().call, "sys_rctl_add_rule"},
+        {wrap<sys_rctl_remove_rule>().call, "sys_rctl_remove_rule"},
+        {wrap<sys_posix_fallocate>().call, "sys_posix_fallocate"},
+        {wrap<sys_posix_fadvise>().call, "sys_posix_fadvise"},
+        {wrap<sys_netcontrol>().call, "sys_netcontrol"},
+        {wrap<sys_netabort>().call, "sys_netabort"},
+        {wrap<sys_netgetsockinfo>().call, "sys_netgetsockinfo"},
+        {wrap<sys_socketex>().call, "sys_socketex"},
+        {wrap<sys_socketclose>().call, "sys_socketclose"},
+        {wrap<sys_netgetiflist>().call, "sys_netgetiflist"},
+        {wrap<sys_kqueueex>().call, "sys_kqueueex"},
+        {wrap<sys_mtypeprotect>().call, "sys_mtypeprotect"},
+        {wrap<sys_regmgr_call>().call, "sys_regmgr_call"},
+        {wrap<sys_jitshm_create>().call, "sys_jitshm_create"},
+        {wrap<sys_jitshm_alias>().call, "sys_jitshm_alias"},
+        {wrap<sys_dl_get_list>().call, "sys_dl_get_list"},
+        {wrap<sys_dl_get_info>().call, "sys_dl_get_info"},
+        {wrap<sys_dl_notify_event>().call, "sys_dl_notify_event"},
+        {wrap<sys_evf_create>().call, "sys_evf_create"},
+        {wrap<sys_evf_delete>().call, "sys_evf_delete"},
+        {wrap<sys_evf_open>().call, "sys_evf_open"},
+        {wrap<sys_evf_close>().call, "sys_evf_close"},
+        {wrap<sys_evf_wait>().call, "sys_evf_wait"},
+        {wrap<sys_evf_trywait>().call, "sys_evf_trywait"},
+        {wrap<sys_evf_set>().call, "sys_evf_set"},
+        {wrap<sys_evf_clear>().call, "sys_evf_clear"},
+        {wrap<sys_evf_cancel>().call, "sys_evf_cancel"},
+        {wrap<sys_query_memory_protection>().call,
+         "sys_query_memory_protection"},
+        {wrap<sys_batch_map>().call, "sys_batch_map"},
+        {wrap<sys_osem_create>().call, "sys_osem_create"},
+        {wrap<sys_osem_delete>().call, "sys_osem_delete"},
+        {wrap<sys_osem_open>().call, "sys_osem_open"},
+        {wrap<sys_osem_close>().call, "sys_osem_close"},
+        {wrap<sys_osem_wait>().call, "sys_osem_wait"},
+        {wrap<sys_osem_trywait>().call, "sys_osem_trywait"},
+        {wrap<sys_osem_post>().call, "sys_osem_post"},
+        {wrap<sys_osem_cancel>().call, "sys_osem_cancel"},
+        {wrap<sys_namedobj_create>().call, "sys_namedobj_create"},
+        {wrap<sys_namedobj_delete>().call, "sys_namedobj_delete"},
+        {wrap<sys_set_vm_container>().call, "sys_set_vm_container"},
+        {wrap<sys_debug_init>().call, "sys_debug_init"},
+        {wrap<sys_suspend_process>().call, "sys_suspend_process"},
+        {wrap<sys_resume_process>().call, "sys_resume_process"},
+        {wrap<sys_opmc_enable>().call, "sys_opmc_enable"},
+        {wrap<sys_opmc_disable>().call, "sys_opmc_disable"},
+        {wrap<sys_opmc_set_ctl>().call, "sys_opmc_set_ctl"},
+        {wrap<sys_opmc_set_ctr>().call, "sys_opmc_set_ctr"},
+        {wrap<sys_opmc_get_ctr>().call, "sys_opmc_get_ctr"},
+        {wrap<sys_budget_create>().call, "sys_budget_create"},
+        {wrap<sys_budget_delete>().call, "sys_budget_delete"},
+        {wrap<sys_budget_get>().call, "sys_budget_get"},
+        {wrap<sys_budget_set>().call, "sys_budget_set"},
+        {wrap<sys_virtual_query>().call, "sys_virtual_query"},
+        {wrap<sys_mdbg_call>().call, "sys_mdbg_call"},
+        {wrap<sys_obs_sblock_create>().call, "sys_obs_sblock_create"},
+        {wrap<sys_obs_sblock_delete>().call, "sys_obs_sblock_delete"},
+        {wrap<sys_obs_sblock_enter>().call, "sys_obs_sblock_enter"},
+        {wrap<sys_obs_sblock_exit>().call, "sys_obs_sblock_exit"},
+        {wrap<sys_obs_sblock_xenter>().call, "sys_obs_sblock_xenter"},
+        {wrap<sys_obs_sblock_xexit>().call, "sys_obs_sblock_xexit"},
+        {wrap<sys_obs_eport_create>().call, "sys_obs_eport_create"},
+        {wrap<sys_obs_eport_delete>().call, "sys_obs_eport_delete"},
+        {wrap<sys_obs_eport_trigger>().call, "sys_obs_eport_trigger"},
+        {wrap<sys_obs_eport_open>().call, "sys_obs_eport_open"},
+        {wrap<sys_obs_eport_close>().call, "sys_obs_eport_close"},
+        {wrap<sys_is_in_sandbox>().call, "sys_is_in_sandbox"},
+        {wrap<sys_dmem_container>().call, "sys_dmem_container"},
+        {wrap<sys_get_authinfo>().call, "sys_get_authinfo"},
+        {wrap<sys_mname>().call, "sys_mname"},
+        {wrap<sys_dynlib_dlopen>().call, "sys_dynlib_dlopen"},
+        {wrap<sys_dynlib_dlclose>().call, "sys_dynlib_dlclose"},
+        {wrap<sys_dynlib_dlsym>().call, "sys_dynlib_dlsym"},
+        {wrap<sys_dynlib_get_list>().call, "sys_dynlib_get_list"},
+        {wrap<sys_dynlib_get_info>().call, "sys_dynlib_get_info"},
+        {wrap<sys_dynlib_load_prx>().call, "sys_dynlib_load_prx"},
+        {wrap<sys_dynlib_unload_prx>().call, "sys_dynlib_unload_prx"},
+        {wrap<sys_dynlib_do_copy_relocations>().call,
+         "sys_dynlib_do_copy_relocations"},
+        {wrap<sys_dynlib_prepare_dlclose>().call, "sys_dynlib_prepare_dlclose"},
+        {wrap<sys_dynlib_get_proc_param>().call, "sys_dynlib_get_proc_param"},
+        {wrap<sys_dynlib_process_needed_and_relocate>().call,
+         "sys_dynlib_process_needed_and_relocate"},
+        {wrap<sys_sandbox_path>().call, "sys_sandbox_path"},
+        {wrap<sys_mdbg_service>().call, "sys_mdbg_service"},
+        {wrap<sys_randomized_path>().call, "sys_randomized_path"},
+        {wrap<sys_rdup>().call, "sys_rdup"},
+        {wrap<sys_dl_get_metadata>().call, "sys_dl_get_metadata"},
+        {wrap<sys_workaround8849>().call, "sys_workaround8849"},
+        {wrap<sys_is_development_mode>().call, "sys_is_development_mode"},
+        {wrap<sys_get_self_auth_info>().call, "sys_get_self_auth_info"},
+        {wrap<sys_dynlib_get_info_ex>().call, "sys_dynlib_get_info_ex"},
+        {wrap<sys_budget_getid>().call, "sys_budget_getid"},
+        {wrap<sys_budget_get_ptype>().call, "sys_budget_get_ptype"},
+        {wrap<sys_get_paging_stats_of_all_threads>().call,
+         "sys_get_paging_stats_of_all_threads"},
+        {wrap<sys_get_proc_type_info>().call, "sys_get_proc_type_info"},
+        {wrap<sys_get_resident_count>().call, "sys_get_resident_count"},
+        {wrap<sys_prepare_to_suspend_process>().call,
+         "sys_prepare_to_suspend_process"},
+        {wrap<sys_get_resident_fmem_count>().call,
+         "sys_get_resident_fmem_count"},
+        {wrap<sys_thr_get_name>().call, "sys_thr_get_name"},
+        {wrap<sys_set_gpo>().call, "sys_set_gpo"},
+        {wrap<sys_get_paging_stats_of_all_objects>().call,
+         "sys_get_paging_stats_of_all_objects"},
+        {wrap<sys_test_debug_rwmem>().call, "sys_test_debug_rwmem"},
+        {wrap<sys_free_stack>().call, "sys_free_stack"},
+        {wrap<sys_suspend_system>().call, "sys_suspend_system"},
+        {wrap<sys_ipmimgr_call>().call, "sys_ipmimgr_call"},
+        {wrap<sys_get_gpo>().call, "sys_get_gpo"},
+        {wrap<sys_get_vm_map_timestamp>().call, "sys_get_vm_map_timestamp"},
+        {wrap<sys_opmc_set_hw>().call, "sys_opmc_set_hw"},
+        {wrap<sys_opmc_get_hw>().call, "sys_opmc_get_hw"},
+        {wrap<sys_get_cpu_usage_all>().call, "sys_get_cpu_usage_all"},
+        {wrap<sys_mmap_dmem>().call, "sys_mmap_dmem"},
+        {wrap<sys_physhm_open>().call, "sys_physhm_open"},
+        {wrap<sys_physhm_unlink>().call, "sys_physhm_unlink"},
+        {wrap<sys_resume_internal_hdd>().call, "sys_resume_internal_hdd"},
+        {wrap<sys_thr_suspend_ucontext>().call, "sys_thr_suspend_ucontext"},
+        {wrap<sys_thr_resume_ucontext>().call, "sys_thr_resume_ucontext"},
+        {wrap<sys_thr_get_ucontext>().call, "sys_thr_get_ucontext"},
+        {wrap<sys_thr_set_ucontext>().call, "sys_thr_set_ucontext"},
+        {wrap<sys_set_timezone_info>().call, "sys_set_timezone_info"},
+        {wrap<sys_set_phys_fmem_limit>().call, "sys_set_phys_fmem_limit"},
+        {wrap<sys_utc_to_localtime>().call, "sys_utc_to_localtime"},
+        {wrap<sys_localtime_to_utc>().call, "sys_localtime_to_utc"},
+        {wrap<sys_set_uevt>().call, "sys_set_uevt"},
+        {wrap<sys_get_cpu_usage_proc>().call, "sys_get_cpu_usage_proc"},
+        {wrap<sys_get_map_statistics>().call, "sys_get_map_statistics"},
+        {wrap<sys_set_chicken_switches>().call, "sys_set_chicken_switches"},
+        {wrap<sys_extend_page_table_pool>().call, "sys_extend_page_table_pool"},
+        {wrap<sys_extend_page_table_pool2>().call,
+         "sys_extend_page_table_pool2"},
+        {wrap<sys_get_kernel_mem_statistics>().call,
+         "sys_get_kernel_mem_statistics"},
+        {wrap<sys_get_sdk_compiled_version>().call,
+         "sys_get_sdk_compiled_version"},
+        {wrap<sys_app_state_change>().call, "sys_app_state_change"},
+        {wrap<sys_dynlib_get_obj_member>().call, "sys_dynlib_get_obj_member"},
+        {wrap<sys_budget_get_ptype_of_budget>().call,
+         "sys_budget_get_ptype_of_budget"},
+        {wrap<sys_prepare_to_resume_process>().call,
+         "sys_prepare_to_resume_process"},
+        {wrap<sys_process_terminate>().call, "sys_process_terminate"},
+        {wrap<sys_blockpool_open>().call, "sys_blockpool_open"},
+        {wrap<sys_blockpool_map>().call, "sys_blockpool_map"},
+        {wrap<sys_blockpool_unmap>().call, "sys_blockpool_unmap"},
+        {wrap<sys_dynlib_get_info_for_libdbg>().call,
+         "sys_dynlib_get_info_for_libdbg"},
+        {wrap<sys_blockpool_batch>().call, "sys_blockpool_batch"},
+        {wrap<sys_fdatasync>().call, "sys_fdatasync"},
+        {wrap<sys_dynlib_get_list2>().call, "sys_dynlib_get_list2"},
+        {wrap<sys_dynlib_get_info2>().call, "sys_dynlib_get_info2"},
+        {wrap<sys_aio_submit>().call, "sys_aio_submit"},
+        {wrap<sys_aio_multi_delete>().call, "sys_aio_multi_delete"},
+        {wrap<sys_aio_multi_wait>().call, "sys_aio_multi_wait"},
+        {wrap<sys_aio_multi_poll>().call, "sys_aio_multi_poll"},
+        {wrap<sys_aio_get_data>().call, "sys_aio_get_data"},
+        {wrap<sys_aio_multi_cancel>().call, "sys_aio_multi_cancel"},
+        {wrap<sys_get_bio_usage_all>().call, "sys_get_bio_usage_all"},
+        {wrap<sys_aio_create>().call, "sys_aio_create"},
+        {wrap<sys_aio_submit_cmd>().call, "sys_aio_submit_cmd"},
+        {wrap<sys_aio_init>().call, "sys_aio_init"},
+        {wrap<sys_get_page_table_stats>().call, "sys_get_page_table_stats"},
+        {wrap<sys_dynlib_get_list_for_libdbg>().call,
+         "sys_dynlib_get_list_for_libdbg"},
+        {wrap<sys_blockpool_move>().call, "sys_blockpool_move"},
+        {wrap<sys_virtual_query_all>().call, "sys_virtual_query_all"},
+        {wrap<sys_reserve_2mb_page>().call, "sys_reserve_2mb_page"},
+        {wrap<sys_cpumode_yield>().call, "sys_cpumode_yield"},
+        {wrap<sys_wait6>().call, "sys_wait6"},
+        {wrap<sys_cap_rights_limit>().call, "sys_cap_rights_limit"},
+        {wrap<sys_cap_ioctls_limit>().call, "sys_cap_ioctls_limit"},
+        {wrap<sys_cap_ioctls_get>().call, "sys_cap_ioctls_get"},
+        {wrap<sys_cap_fcntls_limit>().call, "sys_cap_fcntls_limit"},
+        {wrap<sys_cap_fcntls_get>().call, "sys_cap_fcntls_get"},
+        {wrap<sys_bindat>().call, "sys_bindat"},
+        {wrap<sys_connectat>().call, "sys_connectat"},
+        {wrap<sys_chflagsat>().call, "sys_chflagsat"},
+        {wrap<sys_accept4>().call, "sys_accept4"},
+        {wrap<sys_pipe2>().call, "sys_pipe2"},
+        {wrap<sys_aio_mlock>().call, "sys_aio_mlock"},
+        {wrap<sys_procctl>().call, "sys_procctl"},
+        {wrap<sys_ppoll>().call, "sys_ppoll"},
+        {wrap<sys_futimens>().call, "sys_futimens"},
+        {wrap<sys_utimensat>().call, "sys_utimensat"},
+        {wrap<sys_numa_getaffinity>().call, "sys_numa_getaffinity"},
+        {wrap<sys_numa_setaffinity>().call, "sys_numa_setaffinity"},
+        {wrap<sys_apr_submit>().call, "sys_apr_submit"},
+        {wrap<sys_apr_resolve>().call, "sys_apr_resolve"},
+        {wrap<sys_apr_stat>().call, "sys_apr_stat"},
+        {wrap<sys_apr_wait>().call, "sys_apr_wait"},
+        {wrap<sys_apr_ctrl>().call, "sys_apr_ctrl"},
+        {wrap<sys_get_phys_page_size>().call, "sys_get_phys_page_size"},
+        {wrap<sys_begin_app_mount>().call, "sys_begin_app_mount"},
+        {wrap<sys_end_app_mount>().call, "sys_end_app_mount"},
+        {wrap<sys_fsc2h_ctrl>().call, "sys_fsc2h_ctrl"},
+        {wrap<sys_streamwrite>().call, "sys_streamwrite"},
+        {wrap<sys_app_save>().call, "sys_app_save"},
+        {wrap<sys_app_restore>().call, "sys_app_restore"},
+        {wrap<sys_saved_app_delete>().call, "sys_saved_app_delete"},
+        {wrap<sys_get_ppr_sdk_compiled_version>().call,
+         "sys_get_ppr_sdk_compiled_version"},
+        {wrap<sys_notify_app_event>().call, "sys_notify_app_event"},
+        {wrap<sys_ioreq>().call, "sys_ioreq"},
+        {wrap<sys_openintr>().call, "sys_openintr"},
+        {wrap<sys_dl_get_info_2>().call, "sys_dl_get_info_2"},
+        {wrap<sys_acinfo_add>().call, "sys_acinfo_add"},
+        {wrap<sys_acinfo_delete>().call, "sys_acinfo_delete"},
+        {wrap<sys_acinfo_get_all_for_coredump>().call,
+         "sys_acinfo_get_all_for_coredump"},
+        {wrap<sys_ampr_ctrl_debug>().call, "sys_ampr_ctrl_debug"},
+        {wrap<sys_workspace_ctrl>().call, "sys_workspace_ctrl"},
 };
 
 const char *getSysentName(SysResult (*sysent)(Thread *, uint64_t *)) {
@@ -690,1773 +711,1764 @@ const char *getSysentName(SysResult (*sysent)(Thread *, uint64_t *)) {
 }
 
 static constexpr sysent freebsd9_sysent[] = {
-  wrap<nosys>(),
-  wrap<sys_exit>(),
-  wrap<sys_fork>(),
-  wrap<sys_read>(),
-  wrap<sys_write>(),
-  wrap<sys_open>(),
-  wrap<sys_close>(),
-  wrap<sys_wait4>(),
-  wrap<nosys>(),
-  wrap<sys_link>(),
-  wrap<sys_unlink>(),
-  wrap<nosys>(),
-  wrap<sys_chdir>(),
-  wrap<sys_fchdir>(),
-  wrap<sys_mknod>(),
-  wrap<sys_chmod>(),
-  wrap<sys_chown>(),
-  wrap<sys_obreak>(),
-  wrap<sys_getfsstat>(),
-  wrap<nosys>(),
-  wrap<sys_getpid>(),
-  wrap<sys_mount>(),
-  wrap<sys_unmount>(),
-  wrap<sys_setuid>(),
-  wrap<sys_getuid>(),
-  wrap<sys_geteuid>(),
-  wrap<sys_ptrace>(),
-  wrap<sys_recvmsg>(),
-  wrap<sys_sendmsg>(),
-  wrap<sys_recvfrom>(),
-  wrap<sys_accept>(),
-  wrap<sys_getpeername>(),
-  wrap<sys_getsockname>(),
-  wrap<sys_access>(),
-  wrap<sys_chflags>(),
-  wrap<sys_fchflags>(),
-  wrap<sys_sync>(),
-  wrap<sys_kill>(),
-  wrap<nosys>(),
-  wrap<sys_getppid>(),
-  wrap<nosys>(),
-  wrap<sys_dup>(),
-  wrap<sys_pipe>(),
-  wrap<sys_getegid>(),
-  wrap<sys_profil>(),
-  wrap<sys_ktrace>(),
-  wrap<nosys>(),
-  wrap<sys_getgid>(),
-  wrap<nosys>(),
-  wrap<sys_getlogin>(),
-  wrap<sys_setlogin>(),
-  wrap<sys_acct>(),
-  wrap<nosys>(),
-  wrap<sys_sigaltstack>(),
-  wrap<sys_ioctl>(),
-  wrap<sys_reboot>(),
-  wrap<sys_revoke>(),
-  wrap<sys_symlink>(),
-  wrap<sys_readlink>(),
-  wrap<sys_execve>(),
-  wrap<sys_umask>(),
-  wrap<sys_chroot>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_msync>(),
-  wrap<sys_vfork>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_sbrk>(),
-  wrap<sys_sstk>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_munmap>(),
-  wrap<sys_mprotect>(),
-  wrap<sys_madvise>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_mincore>(),
-  wrap<sys_getgroups>(),
-  wrap<sys_setgroups>(),
-  wrap<sys_getpgrp>(),
-  wrap<sys_setpgid>(),
-  wrap<sys_setitimer>(),
-  wrap<nosys>(),
-  wrap<sys_swapon>(),
-  wrap<sys_getitimer>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_getdtablesize>(),
-  wrap<sys_dup2>(),
-  wrap<nosys>(),
-  wrap<sys_fcntl>(),
-  wrap<sys_select>(),
-  wrap<nosys>(),
-  wrap<sys_fsync>(),
-  wrap<sys_setpriority>(),
-  wrap<sys_socket>(),
-  wrap<sys_connect>(),
-  wrap<nosys>(),
-  wrap<sys_getpriority>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_bind>(),
-  wrap<sys_setsockopt>(),
-  wrap<sys_listen>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_gettimeofday>(),
-  wrap<sys_getrusage>(),
-  wrap<sys_getsockopt>(),
-  wrap<nosys>(),
-  wrap<sys_readv>(),
-  wrap<sys_writev>(),
-  wrap<sys_settimeofday>(),
-  wrap<sys_fchown>(),
-  wrap<sys_fchmod>(),
-  wrap<nosys>(),
-  wrap<sys_setreuid>(),
-  wrap<sys_setregid>(),
-  wrap<sys_rename>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_flock>(),
-  wrap<sys_mkfifo>(),
-  wrap<sys_sendto>(),
-  wrap<sys_shutdown>(),
-  wrap<sys_socketpair>(),
-  wrap<sys_mkdir>(),
-  wrap<sys_rmdir>(),
-  wrap<sys_utimes>(),
-  wrap<nosys>(),
-  wrap<sys_adjtime>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_setsid>(),
-  wrap<sys_quotactl>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_nlm_syscall>(),
-  wrap<sys_nfssvc>(),
-  wrap<nosys>(),
-  wrap<sys_statfs>(),
-  wrap<sys_fstatfs>(),
-  wrap<nosys>(),
-  wrap<sys_lgetfh>(),
-  wrap<sys_getfh>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_sysarch>(),
-  wrap<sys_rtprio>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_semsys>(),
-  wrap<sys_msgsys>(),
-  wrap<sys_shmsys>(),
-  wrap<nosys>(),
-  wrap<sys_freebsd6_pread>(),
-  wrap<sys_freebsd6_pwrite>(),
-  wrap<sys_setfib>(),
-  wrap<sys_ntp_adjtime>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_setgid>(),
-  wrap<sys_setegid>(),
-  wrap<sys_seteuid>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_stat>(),
-  wrap<sys_fstat>(),
-  wrap<sys_lstat>(),
-  wrap<sys_pathconf>(),
-  wrap<sys_fpathconf>(),
-  wrap<nosys>(),
-  wrap<sys_getrlimit>(),
-  wrap<sys_setrlimit>(),
-  wrap<sys_getdirentries>(),
-  wrap<sys_freebsd6_mmap>(),
-  wrap<nosys>(),
-  wrap<sys_freebsd6_lseek>(),
-  wrap<sys_freebsd6_truncate>(),
-  wrap<sys_freebsd6_ftruncate>(),
-  wrap<sys___sysctl>(),
-  wrap<sys_mlock>(),
-  wrap<sys_munlock>(),
-  wrap<sys_undelete>(),
-  wrap<sys_futimes>(),
-  wrap<sys_getpgid>(),
-  wrap<nosys>(),
-  wrap<sys_poll>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys___semctl>(),
-  wrap<sys_semget>(),
-  wrap<sys_semop>(),
-  wrap<nosys>(),
-  wrap<sys_msgctl>(),
-  wrap<sys_msgget>(),
-  wrap<sys_msgsnd>(),
-  wrap<sys_msgrcv>(),
-  wrap<sys_shmat>(),
-  wrap<sys_shmctl>(),
-  wrap<sys_shmdt>(),
-  wrap<sys_shmget>(),
-  wrap<sys_clock_gettime>(),
-  wrap<sys_clock_settime>(),
-  wrap<sys_clock_getres>(),
-  wrap<sys_ktimer_create>(),
-  wrap<sys_ktimer_delete>(),
-  wrap<sys_ktimer_settime>(),
-  wrap<sys_ktimer_gettime>(),
-  wrap<sys_ktimer_getoverrun>(),
-  wrap<sys_nanosleep>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_ntp_gettime>(),
-  wrap<nosys>(),
-  wrap<sys_minherit>(),
-  wrap<sys_rfork>(),
-  wrap<sys_openbsd_poll>(),
-  wrap<sys_issetugid>(),
-  wrap<sys_lchown>(),
-  wrap<sys_aio_read>(),
-  wrap<sys_aio_write>(),
-  wrap<sys_lio_listio>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_getdents>(),
-  wrap<nosys>(),
-  wrap<sys_lchmod>(),
-  wrap<sys_lchown>(),
-  wrap<sys_lutimes>(),
-  wrap<sys_msync>(),
-  wrap<sys_nstat>(),
-  wrap<sys_nfstat>(),
-  wrap<sys_nlstat>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_preadv>(),
-  wrap<sys_pwritev>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_fhstatfs>(),
-  wrap<sys_fhopen>(),
-  wrap<sys_fhstat>(),
-  wrap<sys_modnext>(),
-  wrap<sys_modstat>(),
-  wrap<sys_modfnext>(),
-  wrap<sys_modfind>(),
-  wrap<sys_kldload>(),
-  wrap<sys_kldunload>(),
-  wrap<sys_kldfind>(),
-  wrap<sys_kldnext>(),
-  wrap<sys_kldstat>(),
-  wrap<sys_kldfirstmod>(),
-  wrap<sys_getsid>(),
-  wrap<sys_setresuid>(),
-  wrap<sys_setresgid>(),
-  wrap<nosys>(),
-  wrap<sys_aio_return>(),
-  wrap<sys_aio_suspend>(),
-  wrap<sys_aio_cancel>(),
-  wrap<sys_aio_error>(),
-  wrap<sys_oaio_read>(),
-  wrap<sys_oaio_write>(),
-  wrap<sys_olio_listio>(),
-  wrap<sys_yield>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_mlockall>(),
-  wrap<sys_munlockall>(),
-  wrap<sys___getcwd>(),
-  wrap<sys_sched_setparam>(),
-  wrap<sys_sched_getparam>(),
-  wrap<sys_sched_setscheduler>(),
-  wrap<sys_sched_getscheduler>(),
-  wrap<sys_sched_yield>(),
-  wrap<sys_sched_get_priority_max>(),
-  wrap<sys_sched_get_priority_min>(),
-  wrap<sys_sched_rr_get_interval>(),
-  wrap<sys_utrace>(),
-  wrap<sys_sendfile>(),
-  wrap<sys_kldsym>(),
-  wrap<sys_jail>(),
-  wrap<sys_nnpfs_syscall>(),
-  wrap<sys_sigprocmask>(),
-  wrap<sys_sigsuspend>(),
-  wrap<sys_sigaction>(),
-  wrap<sys_sigpending>(),
-  wrap<sys_sigreturn>(),
-  wrap<sys_sigtimedwait>(),
-  wrap<sys_sigwaitinfo>(),
-  wrap<sys___acl_get_file>(),
-  wrap<sys___acl_set_file>(),
-  wrap<sys___acl_get_fd>(),
-  wrap<sys___acl_set_fd>(),
-  wrap<sys___acl_delete_file>(),
-  wrap<sys___acl_delete_fd>(),
-  wrap<sys___acl_aclcheck_file>(),
-  wrap<sys___acl_aclcheck_fd>(),
-  wrap<sys_extattrctl>(),
-  wrap<sys_extattr_set_file>(),
-  wrap<sys_extattr_get_file>(),
-  wrap<sys_extattr_delete_file>(),
-  wrap<sys_aio_waitcomplete>(),
-  wrap<sys_getresuid>(),
-  wrap<sys_getresgid>(),
-  wrap<sys_kqueue>(),
-  wrap<sys_kevent>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_extattr_set_fd>(),
-  wrap<sys_extattr_get_fd>(),
-  wrap<sys_extattr_delete_fd>(),
-  wrap<sys___setugid>(),
-  wrap<nosys>(),
-  wrap<sys_eaccess>(),
-  wrap<sys_afs3_syscall>(),
-  wrap<sys_nmount>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys___mac_get_proc>(),
-  wrap<sys___mac_set_proc>(),
-  wrap<sys___mac_get_fd>(),
-  wrap<sys___mac_get_file>(),
-  wrap<sys___mac_set_fd>(),
-  wrap<sys___mac_set_file>(),
-  wrap<sys_kenv>(),
-  wrap<sys_lchflags>(),
-  wrap<sys_uuidgen>(),
-  wrap<sys_sendfile>(),
-  wrap<sys_mac_syscall>(),
-  wrap<sys_getfsstat>(),
-  wrap<sys_statfs>(),
-  wrap<sys_fstatfs>(),
-  wrap<sys_fhstatfs>(),
-  wrap<nosys>(),
-  wrap<sys_ksem_close>(),
-  wrap<sys_ksem_post>(),
-  wrap<sys_ksem_wait>(),
-  wrap<sys_ksem_trywait>(),
-  wrap<sys_ksem_init>(),
-  wrap<sys_ksem_open>(),
-  wrap<sys_ksem_unlink>(),
-  wrap<sys_ksem_getvalue>(),
-  wrap<sys_ksem_destroy>(),
-  wrap<sys___mac_get_pid>(),
-  wrap<sys___mac_get_link>(),
-  wrap<sys___mac_set_link>(),
-  wrap<sys_extattr_set_link>(),
-  wrap<sys_extattr_get_link>(),
-  wrap<sys_extattr_delete_link>(),
-  wrap<sys___mac_execve>(),
-  wrap<sys_sigaction>(),
-  wrap<sys_sigreturn>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_getcontext>(),
-  wrap<sys_setcontext>(),
-  wrap<sys_swapcontext>(),
-  wrap<sys_swapoff>(),
-  wrap<sys___acl_get_link>(),
-  wrap<sys___acl_set_link>(),
-  wrap<sys___acl_delete_link>(),
-  wrap<sys___acl_aclcheck_link>(),
-  wrap<sys_sigwait>(),
-  wrap<sys_thr_create>(),
-  wrap<sys_thr_exit>(),
-  wrap<sys_thr_self>(),
-  wrap<sys_thr_kill>(),
-  wrap<sys__umtx_lock>(),
-  wrap<sys__umtx_unlock>(),
-  wrap<sys_jail_attach>(),
-  wrap<sys_extattr_list_fd>(),
-  wrap<sys_extattr_list_file>(),
-  wrap<sys_extattr_list_link>(),
-  wrap<nosys>(),
-  wrap<sys_ksem_timedwait>(),
-  wrap<sys_thr_suspend>(),
-  wrap<sys_thr_wake>(),
-  wrap<sys_kldunloadf>(),
-  wrap<sys_audit>(),
-  wrap<sys_auditon>(),
-  wrap<sys_getauid>(),
-  wrap<sys_setauid>(),
-  wrap<sys_getaudit>(),
-  wrap<sys_setaudit>(),
-  wrap<sys_getaudit_addr>(),
-  wrap<sys_setaudit_addr>(),
-  wrap<sys_auditctl>(),
-  wrap<sys__umtx_op>(),
-  wrap<sys_thr_new>(),
-  wrap<sys_sigqueue>(),
-  wrap<sys_kmq_open>(),
-  wrap<sys_kmq_setattr>(),
-  wrap<sys_kmq_timedreceive>(),
-  wrap<sys_kmq_timedsend>(),
-  wrap<sys_kmq_notify>(),
-  wrap<sys_kmq_unlink>(),
-  wrap<sys_abort2>(),
-  wrap<sys_thr_set_name>(),
-  wrap<sys_aio_fsync>(),
-  wrap<sys_rtprio_thread>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_sctp_peeloff>(),
-  wrap<sys_sctp_generic_sendmsg>(),
-  wrap<sys_sctp_generic_sendmsg_iov>(),
-  wrap<sys_sctp_generic_recvmsg>(),
-  wrap<sys_pread>(),
-  wrap<sys_pwrite>(),
-  wrap<sys_mmap>(),
-  wrap<sys_lseek>(),
-  wrap<sys_truncate>(),
-  wrap<sys_ftruncate>(),
-  wrap<sys_thr_kill2>(),
-  wrap<sys_shm_open>(),
-  wrap<sys_shm_unlink>(),
-  wrap<sys_cpuset>(),
-  wrap<sys_cpuset_setid>(),
-  wrap<sys_cpuset_getid>(),
-  wrap<sys_cpuset_getaffinity>(),
-  wrap<sys_cpuset_setaffinity>(),
-  wrap<sys_faccessat>(),
-  wrap<sys_fchmodat>(),
-  wrap<sys_fchownat>(),
-  wrap<sys_fexecve>(),
-  wrap<sys_fstatat>(),
-  wrap<sys_futimesat>(),
-  wrap<sys_linkat>(),
-  wrap<sys_mkdirat>(),
-  wrap<sys_mkfifoat>(),
-  wrap<sys_mknodat>(),
-  wrap<sys_openat>(),
-  wrap<sys_readlinkat>(),
-  wrap<sys_renameat>(),
-  wrap<sys_symlinkat>(),
-  wrap<sys_unlinkat>(),
-  wrap<sys_posix_openpt>(),
-  wrap<sys_gssd_syscall>(),
-  wrap<sys_jail_get>(),
-  wrap<sys_jail_set>(),
-  wrap<sys_jail_remove>(),
-  wrap<sys_closefrom>(),
-  wrap<sys___semctl>(),
-  wrap<sys_msgctl>(),
-  wrap<sys_shmctl>(),
-  wrap<sys_lpathconf>(),
-  wrap<sys_cap_new>(),
-  wrap<sys_cap_getrights>(),
-  wrap<sys_cap_enter>(),
-  wrap<sys_cap_getmode>(),
-  wrap<sys_pdfork>(),
-  wrap<sys_pdkill>(),
-  wrap<sys_pdgetpid>(),
-  wrap<nosys>(),
-  wrap<sys_pselect>(),
-  wrap<sys_getloginclass>(),
-  wrap<sys_setloginclass>(),
-  wrap<sys_rctl_get_racct>(),
-  wrap<sys_rctl_get_rules>(),
-  wrap<sys_rctl_get_limits>(),
-  wrap<sys_rctl_add_rule>(),
-  wrap<sys_rctl_remove_rule>(),
-  wrap<sys_posix_fallocate>(),
-  wrap<sys_posix_fadvise>(),
+    wrap<nosys>(),
+    wrap<sys_exit>(),
+    wrap<sys_fork>(),
+    wrap<sys_read>(),
+    wrap<sys_write>(),
+    wrap<sys_open>(),
+    wrap<sys_close>(),
+    wrap<sys_wait4>(),
+    wrap<nosys>(),
+    wrap<sys_link>(),
+    wrap<sys_unlink>(),
+    wrap<nosys>(),
+    wrap<sys_chdir>(),
+    wrap<sys_fchdir>(),
+    wrap<sys_mknod>(),
+    wrap<sys_chmod>(),
+    wrap<sys_chown>(),
+    wrap<sys_obreak>(),
+    wrap<sys_getfsstat>(),
+    wrap<nosys>(),
+    wrap<sys_getpid>(),
+    wrap<sys_mount>(),
+    wrap<sys_unmount>(),
+    wrap<sys_setuid>(),
+    wrap<sys_getuid>(),
+    wrap<sys_geteuid>(),
+    wrap<sys_ptrace>(),
+    wrap<sys_recvmsg>(),
+    wrap<sys_sendmsg>(),
+    wrap<sys_recvfrom>(),
+    wrap<sys_accept>(),
+    wrap<sys_getpeername>(),
+    wrap<sys_getsockname>(),
+    wrap<sys_access>(),
+    wrap<sys_chflags>(),
+    wrap<sys_fchflags>(),
+    wrap<sys_sync>(),
+    wrap<sys_kill>(),
+    wrap<nosys>(),
+    wrap<sys_getppid>(),
+    wrap<nosys>(),
+    wrap<sys_dup>(),
+    wrap<sys_pipe>(),
+    wrap<sys_getegid>(),
+    wrap<sys_profil>(),
+    wrap<sys_ktrace>(),
+    wrap<nosys>(),
+    wrap<sys_getgid>(),
+    wrap<nosys>(),
+    wrap<sys_getlogin>(),
+    wrap<sys_setlogin>(),
+    wrap<sys_acct>(),
+    wrap<nosys>(),
+    wrap<sys_sigaltstack>(),
+    wrap<sys_ioctl>(),
+    wrap<sys_reboot>(),
+    wrap<sys_revoke>(),
+    wrap<sys_symlink>(),
+    wrap<sys_readlink>(),
+    wrap<sys_execve>(),
+    wrap<sys_umask>(),
+    wrap<sys_chroot>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_msync>(),
+    wrap<sys_vfork>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_sbrk>(),
+    wrap<sys_sstk>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_munmap>(),
+    wrap<sys_mprotect>(),
+    wrap<sys_madvise>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_mincore>(),
+    wrap<sys_getgroups>(),
+    wrap<sys_setgroups>(),
+    wrap<sys_getpgrp>(),
+    wrap<sys_setpgid>(),
+    wrap<sys_setitimer>(),
+    wrap<nosys>(),
+    wrap<sys_swapon>(),
+    wrap<sys_getitimer>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_getdtablesize>(),
+    wrap<sys_dup2>(),
+    wrap<nosys>(),
+    wrap<sys_fcntl>(),
+    wrap<sys_select>(),
+    wrap<nosys>(),
+    wrap<sys_fsync>(),
+    wrap<sys_setpriority>(),
+    wrap<sys_socket>(),
+    wrap<sys_connect>(),
+    wrap<nosys>(),
+    wrap<sys_getpriority>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_bind>(),
+    wrap<sys_setsockopt>(),
+    wrap<sys_listen>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_gettimeofday>(),
+    wrap<sys_getrusage>(),
+    wrap<sys_getsockopt>(),
+    wrap<nosys>(),
+    wrap<sys_readv>(),
+    wrap<sys_writev>(),
+    wrap<sys_settimeofday>(),
+    wrap<sys_fchown>(),
+    wrap<sys_fchmod>(),
+    wrap<nosys>(),
+    wrap<sys_setreuid>(),
+    wrap<sys_setregid>(),
+    wrap<sys_rename>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_flock>(),
+    wrap<sys_mkfifo>(),
+    wrap<sys_sendto>(),
+    wrap<sys_shutdown>(),
+    wrap<sys_socketpair>(),
+    wrap<sys_mkdir>(),
+    wrap<sys_rmdir>(),
+    wrap<sys_utimes>(),
+    wrap<nosys>(),
+    wrap<sys_adjtime>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_setsid>(),
+    wrap<sys_quotactl>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_nlm_syscall>(),
+    wrap<sys_nfssvc>(),
+    wrap<nosys>(),
+    wrap<sys_statfs>(),
+    wrap<sys_fstatfs>(),
+    wrap<nosys>(),
+    wrap<sys_lgetfh>(),
+    wrap<sys_getfh>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_sysarch>(),
+    wrap<sys_rtprio>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_semsys>(),
+    wrap<sys_msgsys>(),
+    wrap<sys_shmsys>(),
+    wrap<nosys>(),
+    wrap<sys_freebsd6_pread>(),
+    wrap<sys_freebsd6_pwrite>(),
+    wrap<sys_setfib>(),
+    wrap<sys_ntp_adjtime>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_setgid>(),
+    wrap<sys_setegid>(),
+    wrap<sys_seteuid>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_stat>(),
+    wrap<sys_fstat>(),
+    wrap<sys_lstat>(),
+    wrap<sys_pathconf>(),
+    wrap<sys_fpathconf>(),
+    wrap<nosys>(),
+    wrap<sys_getrlimit>(),
+    wrap<sys_setrlimit>(),
+    wrap<sys_getdirentries>(),
+    wrap<sys_freebsd6_mmap>(),
+    wrap<nosys>(),
+    wrap<sys_freebsd6_lseek>(),
+    wrap<sys_freebsd6_truncate>(),
+    wrap<sys_freebsd6_ftruncate>(),
+    wrap<sys___sysctl>(),
+    wrap<sys_mlock>(),
+    wrap<sys_munlock>(),
+    wrap<sys_undelete>(),
+    wrap<sys_futimes>(),
+    wrap<sys_getpgid>(),
+    wrap<nosys>(),
+    wrap<sys_poll>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys___semctl>(),
+    wrap<sys_semget>(),
+    wrap<sys_semop>(),
+    wrap<nosys>(),
+    wrap<sys_msgctl>(),
+    wrap<sys_msgget>(),
+    wrap<sys_msgsnd>(),
+    wrap<sys_msgrcv>(),
+    wrap<sys_shmat>(),
+    wrap<sys_shmctl>(),
+    wrap<sys_shmdt>(),
+    wrap<sys_shmget>(),
+    wrap<sys_clock_gettime>(),
+    wrap<sys_clock_settime>(),
+    wrap<sys_clock_getres>(),
+    wrap<sys_ktimer_create>(),
+    wrap<sys_ktimer_delete>(),
+    wrap<sys_ktimer_settime>(),
+    wrap<sys_ktimer_gettime>(),
+    wrap<sys_ktimer_getoverrun>(),
+    wrap<sys_nanosleep>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_ntp_gettime>(),
+    wrap<nosys>(),
+    wrap<sys_minherit>(),
+    wrap<sys_rfork>(),
+    wrap<sys_openbsd_poll>(),
+    wrap<sys_issetugid>(),
+    wrap<sys_lchown>(),
+    wrap<sys_aio_read>(),
+    wrap<sys_aio_write>(),
+    wrap<sys_lio_listio>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_getdents>(),
+    wrap<nosys>(),
+    wrap<sys_lchmod>(),
+    wrap<sys_lchown>(),
+    wrap<sys_lutimes>(),
+    wrap<sys_msync>(),
+    wrap<sys_nstat>(),
+    wrap<sys_nfstat>(),
+    wrap<sys_nlstat>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_preadv>(),
+    wrap<sys_pwritev>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_fhstatfs>(),
+    wrap<sys_fhopen>(),
+    wrap<sys_fhstat>(),
+    wrap<sys_modnext>(),
+    wrap<sys_modstat>(),
+    wrap<sys_modfnext>(),
+    wrap<sys_modfind>(),
+    wrap<sys_kldload>(),
+    wrap<sys_kldunload>(),
+    wrap<sys_kldfind>(),
+    wrap<sys_kldnext>(),
+    wrap<sys_kldstat>(),
+    wrap<sys_kldfirstmod>(),
+    wrap<sys_getsid>(),
+    wrap<sys_setresuid>(),
+    wrap<sys_setresgid>(),
+    wrap<nosys>(),
+    wrap<sys_aio_return>(),
+    wrap<sys_aio_suspend>(),
+    wrap<sys_aio_cancel>(),
+    wrap<sys_aio_error>(),
+    wrap<sys_oaio_read>(),
+    wrap<sys_oaio_write>(),
+    wrap<sys_olio_listio>(),
+    wrap<sys_yield>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_mlockall>(),
+    wrap<sys_munlockall>(),
+    wrap<sys___getcwd>(),
+    wrap<sys_sched_setparam>(),
+    wrap<sys_sched_getparam>(),
+    wrap<sys_sched_setscheduler>(),
+    wrap<sys_sched_getscheduler>(),
+    wrap<sys_sched_yield>(),
+    wrap<sys_sched_get_priority_max>(),
+    wrap<sys_sched_get_priority_min>(),
+    wrap<sys_sched_rr_get_interval>(),
+    wrap<sys_utrace>(),
+    wrap<sys_sendfile>(),
+    wrap<sys_kldsym>(),
+    wrap<sys_jail>(),
+    wrap<sys_nnpfs_syscall>(),
+    wrap<sys_sigprocmask>(),
+    wrap<sys_sigsuspend>(),
+    wrap<sys_sigaction>(),
+    wrap<sys_sigpending>(),
+    wrap<sys_sigreturn>(),
+    wrap<sys_sigtimedwait>(),
+    wrap<sys_sigwaitinfo>(),
+    wrap<sys___acl_get_file>(),
+    wrap<sys___acl_set_file>(),
+    wrap<sys___acl_get_fd>(),
+    wrap<sys___acl_set_fd>(),
+    wrap<sys___acl_delete_file>(),
+    wrap<sys___acl_delete_fd>(),
+    wrap<sys___acl_aclcheck_file>(),
+    wrap<sys___acl_aclcheck_fd>(),
+    wrap<sys_extattrctl>(),
+    wrap<sys_extattr_set_file>(),
+    wrap<sys_extattr_get_file>(),
+    wrap<sys_extattr_delete_file>(),
+    wrap<sys_aio_waitcomplete>(),
+    wrap<sys_getresuid>(),
+    wrap<sys_getresgid>(),
+    wrap<sys_kqueue>(),
+    wrap<sys_kevent>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_extattr_set_fd>(),
+    wrap<sys_extattr_get_fd>(),
+    wrap<sys_extattr_delete_fd>(),
+    wrap<sys___setugid>(),
+    wrap<nosys>(),
+    wrap<sys_eaccess>(),
+    wrap<sys_afs3_syscall>(),
+    wrap<sys_nmount>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys___mac_get_proc>(),
+    wrap<sys___mac_set_proc>(),
+    wrap<sys___mac_get_fd>(),
+    wrap<sys___mac_get_file>(),
+    wrap<sys___mac_set_fd>(),
+    wrap<sys___mac_set_file>(),
+    wrap<sys_kenv>(),
+    wrap<sys_lchflags>(),
+    wrap<sys_uuidgen>(),
+    wrap<sys_sendfile>(),
+    wrap<sys_mac_syscall>(),
+    wrap<sys_getfsstat>(),
+    wrap<sys_statfs>(),
+    wrap<sys_fstatfs>(),
+    wrap<sys_fhstatfs>(),
+    wrap<nosys>(),
+    wrap<sys_ksem_close>(),
+    wrap<sys_ksem_post>(),
+    wrap<sys_ksem_wait>(),
+    wrap<sys_ksem_trywait>(),
+    wrap<sys_ksem_init>(),
+    wrap<sys_ksem_open>(),
+    wrap<sys_ksem_unlink>(),
+    wrap<sys_ksem_getvalue>(),
+    wrap<sys_ksem_destroy>(),
+    wrap<sys___mac_get_pid>(),
+    wrap<sys___mac_get_link>(),
+    wrap<sys___mac_set_link>(),
+    wrap<sys_extattr_set_link>(),
+    wrap<sys_extattr_get_link>(),
+    wrap<sys_extattr_delete_link>(),
+    wrap<sys___mac_execve>(),
+    wrap<sys_sigaction>(),
+    wrap<sys_sigreturn>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_getcontext>(),
+    wrap<sys_setcontext>(),
+    wrap<sys_swapcontext>(),
+    wrap<sys_swapoff>(),
+    wrap<sys___acl_get_link>(),
+    wrap<sys___acl_set_link>(),
+    wrap<sys___acl_delete_link>(),
+    wrap<sys___acl_aclcheck_link>(),
+    wrap<sys_sigwait>(),
+    wrap<sys_thr_create>(),
+    wrap<sys_thr_exit>(),
+    wrap<sys_thr_self>(),
+    wrap<sys_thr_kill>(),
+    wrap<sys__umtx_lock>(),
+    wrap<sys__umtx_unlock>(),
+    wrap<sys_jail_attach>(),
+    wrap<sys_extattr_list_fd>(),
+    wrap<sys_extattr_list_file>(),
+    wrap<sys_extattr_list_link>(),
+    wrap<nosys>(),
+    wrap<sys_ksem_timedwait>(),
+    wrap<sys_thr_suspend>(),
+    wrap<sys_thr_wake>(),
+    wrap<sys_kldunloadf>(),
+    wrap<sys_audit>(),
+    wrap<sys_auditon>(),
+    wrap<sys_getauid>(),
+    wrap<sys_setauid>(),
+    wrap<sys_getaudit>(),
+    wrap<sys_setaudit>(),
+    wrap<sys_getaudit_addr>(),
+    wrap<sys_setaudit_addr>(),
+    wrap<sys_auditctl>(),
+    wrap<sys__umtx_op>(),
+    wrap<sys_thr_new>(),
+    wrap<sys_sigqueue>(),
+    wrap<sys_kmq_open>(),
+    wrap<sys_kmq_setattr>(),
+    wrap<sys_kmq_timedreceive>(),
+    wrap<sys_kmq_timedsend>(),
+    wrap<sys_kmq_notify>(),
+    wrap<sys_kmq_unlink>(),
+    wrap<sys_abort2>(),
+    wrap<sys_thr_set_name>(),
+    wrap<sys_aio_fsync>(),
+    wrap<sys_rtprio_thread>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_sctp_peeloff>(),
+    wrap<sys_sctp_generic_sendmsg>(),
+    wrap<sys_sctp_generic_sendmsg_iov>(),
+    wrap<sys_sctp_generic_recvmsg>(),
+    wrap<sys_pread>(),
+    wrap<sys_pwrite>(),
+    wrap<sys_mmap>(),
+    wrap<sys_lseek>(),
+    wrap<sys_truncate>(),
+    wrap<sys_ftruncate>(),
+    wrap<sys_thr_kill2>(),
+    wrap<sys_shm_open>(),
+    wrap<sys_shm_unlink>(),
+    wrap<sys_cpuset>(),
+    wrap<sys_cpuset_setid>(),
+    wrap<sys_cpuset_getid>(),
+    wrap<sys_cpuset_getaffinity>(),
+    wrap<sys_cpuset_setaffinity>(),
+    wrap<sys_faccessat>(),
+    wrap<sys_fchmodat>(),
+    wrap<sys_fchownat>(),
+    wrap<sys_fexecve>(),
+    wrap<sys_fstatat>(),
+    wrap<sys_futimesat>(),
+    wrap<sys_linkat>(),
+    wrap<sys_mkdirat>(),
+    wrap<sys_mkfifoat>(),
+    wrap<sys_mknodat>(),
+    wrap<sys_openat>(),
+    wrap<sys_readlinkat>(),
+    wrap<sys_renameat>(),
+    wrap<sys_symlinkat>(),
+    wrap<sys_unlinkat>(),
+    wrap<sys_posix_openpt>(),
+    wrap<sys_gssd_syscall>(),
+    wrap<sys_jail_get>(),
+    wrap<sys_jail_set>(),
+    wrap<sys_jail_remove>(),
+    wrap<sys_closefrom>(),
+    wrap<sys___semctl>(),
+    wrap<sys_msgctl>(),
+    wrap<sys_shmctl>(),
+    wrap<sys_lpathconf>(),
+    wrap<sys_cap_new>(),
+    wrap<sys_cap_getrights>(),
+    wrap<sys_cap_enter>(),
+    wrap<sys_cap_getmode>(),
+    wrap<sys_pdfork>(),
+    wrap<sys_pdkill>(),
+    wrap<sys_pdgetpid>(),
+    wrap<nosys>(),
+    wrap<sys_pselect>(),
+    wrap<sys_getloginclass>(),
+    wrap<sys_setloginclass>(),
+    wrap<sys_rctl_get_racct>(),
+    wrap<sys_rctl_get_rules>(),
+    wrap<sys_rctl_get_limits>(),
+    wrap<sys_rctl_add_rule>(),
+    wrap<sys_rctl_remove_rule>(),
+    wrap<sys_posix_fallocate>(),
+    wrap<sys_posix_fadvise>(),
 };
 
 // TODO
 static constexpr sysent freebsd11_sysent[] = {
-  wrap<nosys>(),
-  wrap<sys_exit>(),
-  wrap<sys_fork>(),
-  wrap<sys_read>(),
-  wrap<sys_write>(),
-  wrap<sys_open>(),
-  wrap<sys_close>(),
-  wrap<sys_wait4>(),
-  wrap<nosys>(),
-  wrap<sys_link>(),
-  wrap<sys_unlink>(),
-  wrap<nosys>(),
-  wrap<sys_chdir>(),
-  wrap<sys_fchdir>(),
-  wrap<sys_mknod>(),
-  wrap<sys_chmod>(),
-  wrap<sys_chown>(),
-  wrap<sys_obreak>(),
-  wrap<sys_getfsstat>(),
-  wrap<nosys>(),
-  wrap<sys_getpid>(),
-  wrap<sys_mount>(),
-  wrap<sys_unmount>(),
-  wrap<sys_setuid>(),
-  wrap<sys_getuid>(),
-  wrap<sys_geteuid>(),
-  wrap<sys_ptrace>(),
-  wrap<sys_recvmsg>(),
-  wrap<sys_sendmsg>(),
-  wrap<sys_recvfrom>(),
-  wrap<sys_accept>(),
-  wrap<sys_getpeername>(),
-  wrap<sys_getsockname>(),
-  wrap<sys_access>(),
-  wrap<sys_chflags>(),
-  wrap<sys_fchflags>(),
-  wrap<sys_sync>(),
-  wrap<sys_kill>(),
-  wrap<nosys>(),
-  wrap<sys_getppid>(),
-  wrap<nosys>(),
-  wrap<sys_dup>(),
-  wrap<sys_pipe>(),
-  wrap<sys_getegid>(),
-  wrap<sys_profil>(),
-  wrap<sys_ktrace>(),
-  wrap<nosys>(),
-  wrap<sys_getgid>(),
-  wrap<nosys>(),
-  wrap<sys_getlogin>(),
-  wrap<sys_setlogin>(),
-  wrap<sys_acct>(),
-  wrap<nosys>(),
-  wrap<sys_sigaltstack>(),
-  wrap<sys_ioctl>(),
-  wrap<sys_reboot>(),
-  wrap<sys_revoke>(),
-  wrap<sys_symlink>(),
-  wrap<sys_readlink>(),
-  wrap<sys_execve>(),
-  wrap<sys_umask>(),
-  wrap<sys_chroot>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_msync>(),
-  wrap<sys_vfork>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_sbrk>(),
-  wrap<sys_sstk>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_munmap>(),
-  wrap<sys_mprotect>(),
-  wrap<sys_madvise>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_mincore>(),
-  wrap<sys_getgroups>(),
-  wrap<sys_setgroups>(),
-  wrap<sys_getpgrp>(),
-  wrap<sys_setpgid>(),
-  wrap<sys_setitimer>(),
-  wrap<nosys>(),
-  wrap<sys_swapon>(),
-  wrap<sys_getitimer>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_getdtablesize>(),
-  wrap<sys_dup2>(),
-  wrap<nosys>(),
-  wrap<sys_fcntl>(),
-  wrap<sys_select>(),
-  wrap<nosys>(),
-  wrap<sys_fsync>(),
-  wrap<sys_setpriority>(),
-  wrap<sys_socket>(),
-  wrap<sys_connect>(),
-  wrap<nosys>(),
-  wrap<sys_getpriority>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_bind>(),
-  wrap<sys_setsockopt>(),
-  wrap<sys_listen>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_gettimeofday>(),
-  wrap<sys_getrusage>(),
-  wrap<sys_getsockopt>(),
-  wrap<nosys>(),
-  wrap<sys_readv>(),
-  wrap<sys_writev>(),
-  wrap<sys_settimeofday>(),
-  wrap<sys_fchown>(),
-  wrap<sys_fchmod>(),
-  wrap<nosys>(),
-  wrap<sys_setreuid>(),
-  wrap<sys_setregid>(),
-  wrap<sys_rename>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_flock>(),
-  wrap<sys_mkfifo>(),
-  wrap<sys_sendto>(),
-  wrap<sys_shutdown>(),
-  wrap<sys_socketpair>(),
-  wrap<sys_mkdir>(),
-  wrap<sys_rmdir>(),
-  wrap<sys_utimes>(),
-  wrap<nosys>(),
-  wrap<sys_adjtime>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_setsid>(),
-  wrap<sys_quotactl>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_nlm_syscall>(),
-  wrap<sys_nfssvc>(),
-  wrap<nosys>(),
-  wrap<sys_statfs>(),
-  wrap<sys_fstatfs>(),
-  wrap<nosys>(),
-  wrap<sys_lgetfh>(),
-  wrap<sys_getfh>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_sysarch>(),
-  wrap<sys_rtprio>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_semsys>(),
-  wrap<sys_msgsys>(),
-  wrap<sys_shmsys>(),
-  wrap<nosys>(),
-  wrap<sys_freebsd6_pread>(),
-  wrap<sys_freebsd6_pwrite>(),
-  wrap<sys_setfib>(),
-  wrap<sys_ntp_adjtime>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_setgid>(),
-  wrap<sys_setegid>(),
-  wrap<sys_seteuid>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_stat>(),
-  wrap<sys_fstat>(),
-  wrap<sys_lstat>(),
-  wrap<sys_pathconf>(),
-  wrap<sys_fpathconf>(),
-  wrap<nosys>(),
-  wrap<sys_getrlimit>(),
-  wrap<sys_setrlimit>(),
-  wrap<sys_getdirentries>(),
-  wrap<sys_freebsd6_mmap>(),
-  wrap<nosys>(),
-  wrap<sys_freebsd6_lseek>(),
-  wrap<sys_freebsd6_truncate>(),
-  wrap<sys_freebsd6_ftruncate>(),
-  wrap<sys___sysctl>(),
-  wrap<sys_mlock>(),
-  wrap<sys_munlock>(),
-  wrap<sys_undelete>(),
-  wrap<sys_futimes>(),
-  wrap<sys_getpgid>(),
-  wrap<nosys>(),
-  wrap<sys_poll>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys___semctl>(),
-  wrap<sys_semget>(),
-  wrap<sys_semop>(),
-  wrap<nosys>(),
-  wrap<sys_msgctl>(),
-  wrap<sys_msgget>(),
-  wrap<sys_msgsnd>(),
-  wrap<sys_msgrcv>(),
-  wrap<sys_shmat>(),
-  wrap<sys_shmctl>(),
-  wrap<sys_shmdt>(),
-  wrap<sys_shmget>(),
-  wrap<sys_clock_gettime>(),
-  wrap<sys_clock_settime>(),
-  wrap<sys_clock_getres>(),
-  wrap<sys_ktimer_create>(),
-  wrap<sys_ktimer_delete>(),
-  wrap<sys_ktimer_settime>(),
-  wrap<sys_ktimer_gettime>(),
-  wrap<sys_ktimer_getoverrun>(),
-  wrap<sys_nanosleep>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_ntp_gettime>(),
-  wrap<nosys>(),
-  wrap<sys_minherit>(),
-  wrap<sys_rfork>(),
-  wrap<sys_openbsd_poll>(),
-  wrap<sys_issetugid>(),
-  wrap<sys_lchown>(),
-  wrap<sys_aio_read>(),
-  wrap<sys_aio_write>(),
-  wrap<sys_lio_listio>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_getdents>(),
-  wrap<nosys>(),
-  wrap<sys_lchmod>(),
-  wrap<sys_lchown>(),
-  wrap<sys_lutimes>(),
-  wrap<sys_msync>(),
-  wrap<sys_nstat>(),
-  wrap<sys_nfstat>(),
-  wrap<sys_nlstat>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_preadv>(),
-  wrap<sys_pwritev>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_fhstatfs>(),
-  wrap<sys_fhopen>(),
-  wrap<sys_fhstat>(),
-  wrap<sys_modnext>(),
-  wrap<sys_modstat>(),
-  wrap<sys_modfnext>(),
-  wrap<sys_modfind>(),
-  wrap<sys_kldload>(),
-  wrap<sys_kldunload>(),
-  wrap<sys_kldfind>(),
-  wrap<sys_kldnext>(),
-  wrap<sys_kldstat>(),
-  wrap<sys_kldfirstmod>(),
-  wrap<sys_getsid>(),
-  wrap<sys_setresuid>(),
-  wrap<sys_setresgid>(),
-  wrap<nosys>(),
-  wrap<sys_aio_return>(),
-  wrap<sys_aio_suspend>(),
-  wrap<sys_aio_cancel>(),
-  wrap<sys_aio_error>(),
-  wrap<sys_oaio_read>(),
-  wrap<sys_oaio_write>(),
-  wrap<sys_olio_listio>(),
-  wrap<sys_yield>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_mlockall>(),
-  wrap<sys_munlockall>(),
-  wrap<sys___getcwd>(),
-  wrap<sys_sched_setparam>(),
-  wrap<sys_sched_getparam>(),
-  wrap<sys_sched_setscheduler>(),
-  wrap<sys_sched_getscheduler>(),
-  wrap<sys_sched_yield>(),
-  wrap<sys_sched_get_priority_max>(),
-  wrap<sys_sched_get_priority_min>(),
-  wrap<sys_sched_rr_get_interval>(),
-  wrap<sys_utrace>(),
-  wrap<sys_sendfile>(),
-  wrap<sys_kldsym>(),
-  wrap<sys_jail>(),
-  wrap<sys_nnpfs_syscall>(),
-  wrap<sys_sigprocmask>(),
-  wrap<sys_sigsuspend>(),
-  wrap<sys_sigaction>(),
-  wrap<sys_sigpending>(),
-  wrap<sys_sigreturn>(),
-  wrap<sys_sigtimedwait>(),
-  wrap<sys_sigwaitinfo>(),
-  wrap<sys___acl_get_file>(),
-  wrap<sys___acl_set_file>(),
-  wrap<sys___acl_get_fd>(),
-  wrap<sys___acl_set_fd>(),
-  wrap<sys___acl_delete_file>(),
-  wrap<sys___acl_delete_fd>(),
-  wrap<sys___acl_aclcheck_file>(),
-  wrap<sys___acl_aclcheck_fd>(),
-  wrap<sys_extattrctl>(),
-  wrap<sys_extattr_set_file>(),
-  wrap<sys_extattr_get_file>(),
-  wrap<sys_extattr_delete_file>(),
-  wrap<sys_aio_waitcomplete>(),
-  wrap<sys_getresuid>(),
-  wrap<sys_getresgid>(),
-  wrap<sys_kqueue>(),
-  wrap<sys_kevent>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_extattr_set_fd>(),
-  wrap<sys_extattr_get_fd>(),
-  wrap<sys_extattr_delete_fd>(),
-  wrap<sys___setugid>(),
-  wrap<nosys>(),
-  wrap<sys_eaccess>(),
-  wrap<sys_afs3_syscall>(),
-  wrap<sys_nmount>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys___mac_get_proc>(),
-  wrap<sys___mac_set_proc>(),
-  wrap<sys___mac_get_fd>(),
-  wrap<sys___mac_get_file>(),
-  wrap<sys___mac_set_fd>(),
-  wrap<sys___mac_set_file>(),
-  wrap<sys_kenv>(),
-  wrap<sys_lchflags>(),
-  wrap<sys_uuidgen>(),
-  wrap<sys_sendfile>(),
-  wrap<sys_mac_syscall>(),
-  wrap<sys_getfsstat>(),
-  wrap<sys_statfs>(),
-  wrap<sys_fstatfs>(),
-  wrap<sys_fhstatfs>(),
-  wrap<nosys>(),
-  wrap<sys_ksem_close>(),
-  wrap<sys_ksem_post>(),
-  wrap<sys_ksem_wait>(),
-  wrap<sys_ksem_trywait>(),
-  wrap<sys_ksem_init>(),
-  wrap<sys_ksem_open>(),
-  wrap<sys_ksem_unlink>(),
-  wrap<sys_ksem_getvalue>(),
-  wrap<sys_ksem_destroy>(),
-  wrap<sys___mac_get_pid>(),
-  wrap<sys___mac_get_link>(),
-  wrap<sys___mac_set_link>(),
-  wrap<sys_extattr_set_link>(),
-  wrap<sys_extattr_get_link>(),
-  wrap<sys_extattr_delete_link>(),
-  wrap<sys___mac_execve>(),
-  wrap<sys_sigaction>(),
-  wrap<sys_sigreturn>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_getcontext>(),
-  wrap<sys_setcontext>(),
-  wrap<sys_swapcontext>(),
-  wrap<sys_swapoff>(),
-  wrap<sys___acl_get_link>(),
-  wrap<sys___acl_set_link>(),
-  wrap<sys___acl_delete_link>(),
-  wrap<sys___acl_aclcheck_link>(),
-  wrap<sys_sigwait>(),
-  wrap<sys_thr_create>(),
-  wrap<sys_thr_exit>(),
-  wrap<sys_thr_self>(),
-  wrap<sys_thr_kill>(),
-  wrap<sys__umtx_lock>(),
-  wrap<sys__umtx_unlock>(),
-  wrap<sys_jail_attach>(),
-  wrap<sys_extattr_list_fd>(),
-  wrap<sys_extattr_list_file>(),
-  wrap<sys_extattr_list_link>(),
-  wrap<nosys>(),
-  wrap<sys_ksem_timedwait>(),
-  wrap<sys_thr_suspend>(),
-  wrap<sys_thr_wake>(),
-  wrap<sys_kldunloadf>(),
-  wrap<sys_audit>(),
-  wrap<sys_auditon>(),
-  wrap<sys_getauid>(),
-  wrap<sys_setauid>(),
-  wrap<sys_getaudit>(),
-  wrap<sys_setaudit>(),
-  wrap<sys_getaudit_addr>(),
-  wrap<sys_setaudit_addr>(),
-  wrap<sys_auditctl>(),
-  wrap<sys__umtx_op>(),
-  wrap<sys_thr_new>(),
-  wrap<sys_sigqueue>(),
-  wrap<sys_kmq_open>(),
-  wrap<sys_kmq_setattr>(),
-  wrap<sys_kmq_timedreceive>(),
-  wrap<sys_kmq_timedsend>(),
-  wrap<sys_kmq_notify>(),
-  wrap<sys_kmq_unlink>(),
-  wrap<sys_abort2>(),
-  wrap<sys_thr_set_name>(),
-  wrap<sys_aio_fsync>(),
-  wrap<sys_rtprio_thread>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_sctp_peeloff>(),
-  wrap<sys_sctp_generic_sendmsg>(),
-  wrap<sys_sctp_generic_sendmsg_iov>(),
-  wrap<sys_sctp_generic_recvmsg>(),
-  wrap<sys_pread>(),
-  wrap<sys_pwrite>(),
-  wrap<sys_mmap>(),
-  wrap<sys_lseek>(),
-  wrap<sys_truncate>(),
-  wrap<sys_ftruncate>(),
-  wrap<sys_thr_kill2>(),
-  wrap<sys_shm_open>(),
-  wrap<sys_shm_unlink>(),
-  wrap<sys_cpuset>(),
-  wrap<sys_cpuset_setid>(),
-  wrap<sys_cpuset_getid>(),
-  wrap<sys_cpuset_getaffinity>(),
-  wrap<sys_cpuset_setaffinity>(),
-  wrap<sys_faccessat>(),
-  wrap<sys_fchmodat>(),
-  wrap<sys_fchownat>(),
-  wrap<sys_fexecve>(),
-  wrap<sys_fstatat>(),
-  wrap<sys_futimesat>(),
-  wrap<sys_linkat>(),
-  wrap<sys_mkdirat>(),
-  wrap<sys_mkfifoat>(),
-  wrap<sys_mknodat>(),
-  wrap<sys_openat>(),
-  wrap<sys_readlinkat>(),
-  wrap<sys_renameat>(),
-  wrap<sys_symlinkat>(),
-  wrap<sys_unlinkat>(),
-  wrap<sys_posix_openpt>(),
-  wrap<sys_gssd_syscall>(),
-  wrap<sys_jail_get>(),
-  wrap<sys_jail_set>(),
-  wrap<sys_jail_remove>(),
-  wrap<sys_closefrom>(),
-  wrap<sys___semctl>(),
-  wrap<sys_msgctl>(),
-  wrap<sys_shmctl>(),
-  wrap<sys_lpathconf>(),
-  wrap<sys_cap_new>(),
-  wrap<sys_cap_getrights>(),
-  wrap<sys_cap_enter>(),
-  wrap<sys_cap_getmode>(),
-  wrap<sys_pdfork>(),
-  wrap<sys_pdkill>(),
-  wrap<sys_pdgetpid>(),
-  wrap<nosys>(),
-  wrap<sys_pselect>(),
-  wrap<sys_getloginclass>(),
-  wrap<sys_setloginclass>(),
-  wrap<sys_rctl_get_racct>(),
-  wrap<sys_rctl_get_rules>(),
-  wrap<sys_rctl_get_limits>(),
-  wrap<sys_rctl_add_rule>(),
-  wrap<sys_rctl_remove_rule>(),
-  wrap<sys_posix_fallocate>(),
-  wrap<sys_posix_fadvise>(),
+    wrap<nosys>(),
+    wrap<sys_exit>(),
+    wrap<sys_fork>(),
+    wrap<sys_read>(),
+    wrap<sys_write>(),
+    wrap<sys_open>(),
+    wrap<sys_close>(),
+    wrap<sys_wait4>(),
+    wrap<nosys>(),
+    wrap<sys_link>(),
+    wrap<sys_unlink>(),
+    wrap<nosys>(),
+    wrap<sys_chdir>(),
+    wrap<sys_fchdir>(),
+    wrap<sys_mknod>(),
+    wrap<sys_chmod>(),
+    wrap<sys_chown>(),
+    wrap<sys_obreak>(),
+    wrap<sys_getfsstat>(),
+    wrap<nosys>(),
+    wrap<sys_getpid>(),
+    wrap<sys_mount>(),
+    wrap<sys_unmount>(),
+    wrap<sys_setuid>(),
+    wrap<sys_getuid>(),
+    wrap<sys_geteuid>(),
+    wrap<sys_ptrace>(),
+    wrap<sys_recvmsg>(),
+    wrap<sys_sendmsg>(),
+    wrap<sys_recvfrom>(),
+    wrap<sys_accept>(),
+    wrap<sys_getpeername>(),
+    wrap<sys_getsockname>(),
+    wrap<sys_access>(),
+    wrap<sys_chflags>(),
+    wrap<sys_fchflags>(),
+    wrap<sys_sync>(),
+    wrap<sys_kill>(),
+    wrap<nosys>(),
+    wrap<sys_getppid>(),
+    wrap<nosys>(),
+    wrap<sys_dup>(),
+    wrap<sys_pipe>(),
+    wrap<sys_getegid>(),
+    wrap<sys_profil>(),
+    wrap<sys_ktrace>(),
+    wrap<nosys>(),
+    wrap<sys_getgid>(),
+    wrap<nosys>(),
+    wrap<sys_getlogin>(),
+    wrap<sys_setlogin>(),
+    wrap<sys_acct>(),
+    wrap<nosys>(),
+    wrap<sys_sigaltstack>(),
+    wrap<sys_ioctl>(),
+    wrap<sys_reboot>(),
+    wrap<sys_revoke>(),
+    wrap<sys_symlink>(),
+    wrap<sys_readlink>(),
+    wrap<sys_execve>(),
+    wrap<sys_umask>(),
+    wrap<sys_chroot>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_msync>(),
+    wrap<sys_vfork>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_sbrk>(),
+    wrap<sys_sstk>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_munmap>(),
+    wrap<sys_mprotect>(),
+    wrap<sys_madvise>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_mincore>(),
+    wrap<sys_getgroups>(),
+    wrap<sys_setgroups>(),
+    wrap<sys_getpgrp>(),
+    wrap<sys_setpgid>(),
+    wrap<sys_setitimer>(),
+    wrap<nosys>(),
+    wrap<sys_swapon>(),
+    wrap<sys_getitimer>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_getdtablesize>(),
+    wrap<sys_dup2>(),
+    wrap<nosys>(),
+    wrap<sys_fcntl>(),
+    wrap<sys_select>(),
+    wrap<nosys>(),
+    wrap<sys_fsync>(),
+    wrap<sys_setpriority>(),
+    wrap<sys_socket>(),
+    wrap<sys_connect>(),
+    wrap<nosys>(),
+    wrap<sys_getpriority>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_bind>(),
+    wrap<sys_setsockopt>(),
+    wrap<sys_listen>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_gettimeofday>(),
+    wrap<sys_getrusage>(),
+    wrap<sys_getsockopt>(),
+    wrap<nosys>(),
+    wrap<sys_readv>(),
+    wrap<sys_writev>(),
+    wrap<sys_settimeofday>(),
+    wrap<sys_fchown>(),
+    wrap<sys_fchmod>(),
+    wrap<nosys>(),
+    wrap<sys_setreuid>(),
+    wrap<sys_setregid>(),
+    wrap<sys_rename>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_flock>(),
+    wrap<sys_mkfifo>(),
+    wrap<sys_sendto>(),
+    wrap<sys_shutdown>(),
+    wrap<sys_socketpair>(),
+    wrap<sys_mkdir>(),
+    wrap<sys_rmdir>(),
+    wrap<sys_utimes>(),
+    wrap<nosys>(),
+    wrap<sys_adjtime>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_setsid>(),
+    wrap<sys_quotactl>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_nlm_syscall>(),
+    wrap<sys_nfssvc>(),
+    wrap<nosys>(),
+    wrap<sys_statfs>(),
+    wrap<sys_fstatfs>(),
+    wrap<nosys>(),
+    wrap<sys_lgetfh>(),
+    wrap<sys_getfh>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_sysarch>(),
+    wrap<sys_rtprio>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_semsys>(),
+    wrap<sys_msgsys>(),
+    wrap<sys_shmsys>(),
+    wrap<nosys>(),
+    wrap<sys_freebsd6_pread>(),
+    wrap<sys_freebsd6_pwrite>(),
+    wrap<sys_setfib>(),
+    wrap<sys_ntp_adjtime>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_setgid>(),
+    wrap<sys_setegid>(),
+    wrap<sys_seteuid>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_stat>(),
+    wrap<sys_fstat>(),
+    wrap<sys_lstat>(),
+    wrap<sys_pathconf>(),
+    wrap<sys_fpathconf>(),
+    wrap<nosys>(),
+    wrap<sys_getrlimit>(),
+    wrap<sys_setrlimit>(),
+    wrap<sys_getdirentries>(),
+    wrap<sys_freebsd6_mmap>(),
+    wrap<nosys>(),
+    wrap<sys_freebsd6_lseek>(),
+    wrap<sys_freebsd6_truncate>(),
+    wrap<sys_freebsd6_ftruncate>(),
+    wrap<sys___sysctl>(),
+    wrap<sys_mlock>(),
+    wrap<sys_munlock>(),
+    wrap<sys_undelete>(),
+    wrap<sys_futimes>(),
+    wrap<sys_getpgid>(),
+    wrap<nosys>(),
+    wrap<sys_poll>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys___semctl>(),
+    wrap<sys_semget>(),
+    wrap<sys_semop>(),
+    wrap<nosys>(),
+    wrap<sys_msgctl>(),
+    wrap<sys_msgget>(),
+    wrap<sys_msgsnd>(),
+    wrap<sys_msgrcv>(),
+    wrap<sys_shmat>(),
+    wrap<sys_shmctl>(),
+    wrap<sys_shmdt>(),
+    wrap<sys_shmget>(),
+    wrap<sys_clock_gettime>(),
+    wrap<sys_clock_settime>(),
+    wrap<sys_clock_getres>(),
+    wrap<sys_ktimer_create>(),
+    wrap<sys_ktimer_delete>(),
+    wrap<sys_ktimer_settime>(),
+    wrap<sys_ktimer_gettime>(),
+    wrap<sys_ktimer_getoverrun>(),
+    wrap<sys_nanosleep>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_ntp_gettime>(),
+    wrap<nosys>(),
+    wrap<sys_minherit>(),
+    wrap<sys_rfork>(),
+    wrap<sys_openbsd_poll>(),
+    wrap<sys_issetugid>(),
+    wrap<sys_lchown>(),
+    wrap<sys_aio_read>(),
+    wrap<sys_aio_write>(),
+    wrap<sys_lio_listio>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_getdents>(),
+    wrap<nosys>(),
+    wrap<sys_lchmod>(),
+    wrap<sys_lchown>(),
+    wrap<sys_lutimes>(),
+    wrap<sys_msync>(),
+    wrap<sys_nstat>(),
+    wrap<sys_nfstat>(),
+    wrap<sys_nlstat>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_preadv>(),
+    wrap<sys_pwritev>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_fhstatfs>(),
+    wrap<sys_fhopen>(),
+    wrap<sys_fhstat>(),
+    wrap<sys_modnext>(),
+    wrap<sys_modstat>(),
+    wrap<sys_modfnext>(),
+    wrap<sys_modfind>(),
+    wrap<sys_kldload>(),
+    wrap<sys_kldunload>(),
+    wrap<sys_kldfind>(),
+    wrap<sys_kldnext>(),
+    wrap<sys_kldstat>(),
+    wrap<sys_kldfirstmod>(),
+    wrap<sys_getsid>(),
+    wrap<sys_setresuid>(),
+    wrap<sys_setresgid>(),
+    wrap<nosys>(),
+    wrap<sys_aio_return>(),
+    wrap<sys_aio_suspend>(),
+    wrap<sys_aio_cancel>(),
+    wrap<sys_aio_error>(),
+    wrap<sys_oaio_read>(),
+    wrap<sys_oaio_write>(),
+    wrap<sys_olio_listio>(),
+    wrap<sys_yield>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_mlockall>(),
+    wrap<sys_munlockall>(),
+    wrap<sys___getcwd>(),
+    wrap<sys_sched_setparam>(),
+    wrap<sys_sched_getparam>(),
+    wrap<sys_sched_setscheduler>(),
+    wrap<sys_sched_getscheduler>(),
+    wrap<sys_sched_yield>(),
+    wrap<sys_sched_get_priority_max>(),
+    wrap<sys_sched_get_priority_min>(),
+    wrap<sys_sched_rr_get_interval>(),
+    wrap<sys_utrace>(),
+    wrap<sys_sendfile>(),
+    wrap<sys_kldsym>(),
+    wrap<sys_jail>(),
+    wrap<sys_nnpfs_syscall>(),
+    wrap<sys_sigprocmask>(),
+    wrap<sys_sigsuspend>(),
+    wrap<sys_sigaction>(),
+    wrap<sys_sigpending>(),
+    wrap<sys_sigreturn>(),
+    wrap<sys_sigtimedwait>(),
+    wrap<sys_sigwaitinfo>(),
+    wrap<sys___acl_get_file>(),
+    wrap<sys___acl_set_file>(),
+    wrap<sys___acl_get_fd>(),
+    wrap<sys___acl_set_fd>(),
+    wrap<sys___acl_delete_file>(),
+    wrap<sys___acl_delete_fd>(),
+    wrap<sys___acl_aclcheck_file>(),
+    wrap<sys___acl_aclcheck_fd>(),
+    wrap<sys_extattrctl>(),
+    wrap<sys_extattr_set_file>(),
+    wrap<sys_extattr_get_file>(),
+    wrap<sys_extattr_delete_file>(),
+    wrap<sys_aio_waitcomplete>(),
+    wrap<sys_getresuid>(),
+    wrap<sys_getresgid>(),
+    wrap<sys_kqueue>(),
+    wrap<sys_kevent>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_extattr_set_fd>(),
+    wrap<sys_extattr_get_fd>(),
+    wrap<sys_extattr_delete_fd>(),
+    wrap<sys___setugid>(),
+    wrap<nosys>(),
+    wrap<sys_eaccess>(),
+    wrap<sys_afs3_syscall>(),
+    wrap<sys_nmount>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys___mac_get_proc>(),
+    wrap<sys___mac_set_proc>(),
+    wrap<sys___mac_get_fd>(),
+    wrap<sys___mac_get_file>(),
+    wrap<sys___mac_set_fd>(),
+    wrap<sys___mac_set_file>(),
+    wrap<sys_kenv>(),
+    wrap<sys_lchflags>(),
+    wrap<sys_uuidgen>(),
+    wrap<sys_sendfile>(),
+    wrap<sys_mac_syscall>(),
+    wrap<sys_getfsstat>(),
+    wrap<sys_statfs>(),
+    wrap<sys_fstatfs>(),
+    wrap<sys_fhstatfs>(),
+    wrap<nosys>(),
+    wrap<sys_ksem_close>(),
+    wrap<sys_ksem_post>(),
+    wrap<sys_ksem_wait>(),
+    wrap<sys_ksem_trywait>(),
+    wrap<sys_ksem_init>(),
+    wrap<sys_ksem_open>(),
+    wrap<sys_ksem_unlink>(),
+    wrap<sys_ksem_getvalue>(),
+    wrap<sys_ksem_destroy>(),
+    wrap<sys___mac_get_pid>(),
+    wrap<sys___mac_get_link>(),
+    wrap<sys___mac_set_link>(),
+    wrap<sys_extattr_set_link>(),
+    wrap<sys_extattr_get_link>(),
+    wrap<sys_extattr_delete_link>(),
+    wrap<sys___mac_execve>(),
+    wrap<sys_sigaction>(),
+    wrap<sys_sigreturn>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_getcontext>(),
+    wrap<sys_setcontext>(),
+    wrap<sys_swapcontext>(),
+    wrap<sys_swapoff>(),
+    wrap<sys___acl_get_link>(),
+    wrap<sys___acl_set_link>(),
+    wrap<sys___acl_delete_link>(),
+    wrap<sys___acl_aclcheck_link>(),
+    wrap<sys_sigwait>(),
+    wrap<sys_thr_create>(),
+    wrap<sys_thr_exit>(),
+    wrap<sys_thr_self>(),
+    wrap<sys_thr_kill>(),
+    wrap<sys__umtx_lock>(),
+    wrap<sys__umtx_unlock>(),
+    wrap<sys_jail_attach>(),
+    wrap<sys_extattr_list_fd>(),
+    wrap<sys_extattr_list_file>(),
+    wrap<sys_extattr_list_link>(),
+    wrap<nosys>(),
+    wrap<sys_ksem_timedwait>(),
+    wrap<sys_thr_suspend>(),
+    wrap<sys_thr_wake>(),
+    wrap<sys_kldunloadf>(),
+    wrap<sys_audit>(),
+    wrap<sys_auditon>(),
+    wrap<sys_getauid>(),
+    wrap<sys_setauid>(),
+    wrap<sys_getaudit>(),
+    wrap<sys_setaudit>(),
+    wrap<sys_getaudit_addr>(),
+    wrap<sys_setaudit_addr>(),
+    wrap<sys_auditctl>(),
+    wrap<sys__umtx_op>(),
+    wrap<sys_thr_new>(),
+    wrap<sys_sigqueue>(),
+    wrap<sys_kmq_open>(),
+    wrap<sys_kmq_setattr>(),
+    wrap<sys_kmq_timedreceive>(),
+    wrap<sys_kmq_timedsend>(),
+    wrap<sys_kmq_notify>(),
+    wrap<sys_kmq_unlink>(),
+    wrap<sys_abort2>(),
+    wrap<sys_thr_set_name>(),
+    wrap<sys_aio_fsync>(),
+    wrap<sys_rtprio_thread>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_sctp_peeloff>(),
+    wrap<sys_sctp_generic_sendmsg>(),
+    wrap<sys_sctp_generic_sendmsg_iov>(),
+    wrap<sys_sctp_generic_recvmsg>(),
+    wrap<sys_pread>(),
+    wrap<sys_pwrite>(),
+    wrap<sys_mmap>(),
+    wrap<sys_lseek>(),
+    wrap<sys_truncate>(),
+    wrap<sys_ftruncate>(),
+    wrap<sys_thr_kill2>(),
+    wrap<sys_shm_open>(),
+    wrap<sys_shm_unlink>(),
+    wrap<sys_cpuset>(),
+    wrap<sys_cpuset_setid>(),
+    wrap<sys_cpuset_getid>(),
+    wrap<sys_cpuset_getaffinity>(),
+    wrap<sys_cpuset_setaffinity>(),
+    wrap<sys_faccessat>(),
+    wrap<sys_fchmodat>(),
+    wrap<sys_fchownat>(),
+    wrap<sys_fexecve>(),
+    wrap<sys_fstatat>(),
+    wrap<sys_futimesat>(),
+    wrap<sys_linkat>(),
+    wrap<sys_mkdirat>(),
+    wrap<sys_mkfifoat>(),
+    wrap<sys_mknodat>(),
+    wrap<sys_openat>(),
+    wrap<sys_readlinkat>(),
+    wrap<sys_renameat>(),
+    wrap<sys_symlinkat>(),
+    wrap<sys_unlinkat>(),
+    wrap<sys_posix_openpt>(),
+    wrap<sys_gssd_syscall>(),
+    wrap<sys_jail_get>(),
+    wrap<sys_jail_set>(),
+    wrap<sys_jail_remove>(),
+    wrap<sys_closefrom>(),
+    wrap<sys___semctl>(),
+    wrap<sys_msgctl>(),
+    wrap<sys_shmctl>(),
+    wrap<sys_lpathconf>(),
+    wrap<sys_cap_new>(),
+    wrap<sys_cap_getrights>(),
+    wrap<sys_cap_enter>(),
+    wrap<sys_cap_getmode>(),
+    wrap<sys_pdfork>(),
+    wrap<sys_pdkill>(),
+    wrap<sys_pdgetpid>(),
+    wrap<nosys>(),
+    wrap<sys_pselect>(),
+    wrap<sys_getloginclass>(),
+    wrap<sys_setloginclass>(),
+    wrap<sys_rctl_get_racct>(),
+    wrap<sys_rctl_get_rules>(),
+    wrap<sys_rctl_get_limits>(),
+    wrap<sys_rctl_add_rule>(),
+    wrap<sys_rctl_remove_rule>(),
+    wrap<sys_posix_fallocate>(),
+    wrap<sys_posix_fadvise>(),
 };
 
 static constexpr sysent ps4_sysent[] = {
-  wrap<nosys>(),
-  wrap<sys_exit>(),
-  wrap<sys_fork>(),
-  wrap<sys_read>(),
-  wrap<sys_write>(),
-  wrap<sys_open>(),
-  wrap<sys_close>(),
-  wrap<sys_wait4>(),
-  wrap<nosys>(),
-  wrap<sys_link>(),
-  wrap<sys_unlink>(),
-  wrap<nosys>(),
-  wrap<sys_chdir>(),
-  wrap<sys_fchdir>(),
-  wrap<sys_mknod>(),
-  wrap<sys_chmod>(),
-  wrap<sys_chown>(),
-  wrap<sys_obreak>(),
-  wrap<sys_getfsstat>(),
-  wrap<nosys>(),
-  wrap<sys_getpid>(),
-  wrap<sys_mount>(),
-  wrap<sys_unmount>(),
-  wrap<sys_setuid>(),
-  wrap<sys_getuid>(),
-  wrap<sys_geteuid>(),
-  wrap<sys_ptrace>(),
-  wrap<sys_recvmsg>(),
-  wrap<sys_sendmsg>(),
-  wrap<sys_recvfrom>(),
-  wrap<sys_accept>(),
-  wrap<sys_getpeername>(),
-  wrap<sys_getsockname>(),
-  wrap<sys_access>(),
-  wrap<sys_chflags>(),
-  wrap<sys_fchflags>(),
-  wrap<sys_sync>(),
-  wrap<sys_kill>(),
-  wrap<nosys>(),
-  wrap<sys_getppid>(),
-  wrap<nosys>(),
-  wrap<sys_dup>(),
-  wrap<sys_pipe>(),
-  wrap<sys_getegid>(),
-  wrap<sys_profil>(),
-  wrap<sys_ktrace>(),
-  wrap<nosys>(),
-  wrap<sys_getgid>(),
-  wrap<nosys>(),
-  wrap<sys_getlogin>(),
-  wrap<sys_setlogin>(),
-  wrap<sys_acct>(),
-  wrap<nosys>(),
-  wrap<sys_sigaltstack>(),
-  wrap<sys_ioctl>(),
-  wrap<sys_reboot>(),
-  wrap<sys_revoke>(),
-  wrap<sys_symlink>(),
-  wrap<sys_readlink>(),
-  wrap<sys_execve>(),
-  wrap<sys_umask>(),
-  wrap<sys_chroot>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_msync>(),
-  wrap<sys_vfork>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_sbrk>(),
-  wrap<sys_sstk>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_munmap>(),
-  wrap<sys_mprotect>(),
-  wrap<sys_madvise>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_mincore>(),
-  wrap<sys_getgroups>(),
-  wrap<sys_setgroups>(),
-  wrap<sys_getpgrp>(),
-  wrap<sys_setpgid>(),
-  wrap<sys_setitimer>(),
-  wrap<nosys>(),
-  wrap<sys_swapon>(),
-  wrap<sys_getitimer>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_getdtablesize>(),
-  wrap<sys_dup2>(),
-  wrap<nosys>(),
-  wrap<sys_fcntl>(),
-  wrap<sys_select>(),
-  wrap<nosys>(),
-  wrap<sys_fsync>(),
-  wrap<sys_setpriority>(),
-  wrap<sys_socket>(),
-  wrap<sys_connect>(),
-  wrap<sys_netcontrol>(),
-  wrap<sys_getpriority>(),
-  wrap<sys_netabort>(),
-  wrap<sys_netgetsockinfo>(),
-  wrap<nosys>(),
-  wrap<sys_bind>(),
-  wrap<sys_setsockopt>(),
-  wrap<sys_listen>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_socketex>(),
-  wrap<sys_socketclose>(),
-  wrap<nosys>(),
-  wrap<sys_gettimeofday>(),
-  wrap<sys_getrusage>(),
-  wrap<sys_getsockopt>(),
-  wrap<nosys>(),
-  wrap<sys_readv>(),
-  wrap<sys_writev>(),
-  wrap<sys_settimeofday>(),
-  wrap<sys_fchown>(),
-  wrap<sys_fchmod>(),
-  wrap<sys_netgetiflist>(),
-  wrap<sys_setreuid>(),
-  wrap<sys_setregid>(),
-  wrap<sys_rename>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_flock>(),
-  wrap<sys_mkfifo>(),
-  wrap<sys_sendto>(),
-  wrap<sys_shutdown>(),
-  wrap<sys_socketpair>(),
-  wrap<sys_mkdir>(),
-  wrap<sys_rmdir>(),
-  wrap<sys_utimes>(),
-  wrap<nosys>(),
-  wrap<sys_adjtime>(),
-  wrap<sys_kqueueex>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_setsid>(),
-  wrap<sys_quotactl>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_nlm_syscall>(),
-  wrap<sys_nfssvc>(),
-  wrap<nosys>(),
-  wrap<sys_statfs>(),
-  wrap<sys_fstatfs>(),
-  wrap<nosys>(),
-  wrap<sys_lgetfh>(),
-  wrap<sys_getfh>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_sysarch>(),
-  wrap<sys_rtprio>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_semsys>(),
-  wrap<sys_msgsys>(),
-  wrap<sys_shmsys>(),
-  wrap<nosys>(),
-  wrap<sys_freebsd6_pread>(),
-  wrap<sys_freebsd6_pwrite>(),
-  wrap<sys_setfib>(),
-  wrap<sys_ntp_adjtime>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_setgid>(),
-  wrap<sys_setegid>(),
-  wrap<sys_seteuid>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_stat>(),
-  wrap<sys_fstat>(),
-  wrap<sys_lstat>(),
-  wrap<sys_pathconf>(),
-  wrap<sys_fpathconf>(),
-  wrap<nosys>(),
-  wrap<sys_getrlimit>(),
-  wrap<sys_setrlimit>(),
-  wrap<sys_getdirentries>(),
-  wrap<sys_freebsd6_mmap>(),
-  wrap<nosys>(),
-  wrap<sys_freebsd6_lseek>(),
-  wrap<sys_freebsd6_truncate>(),
-  wrap<sys_freebsd6_ftruncate>(),
-  wrap<sys___sysctl>(),
-  wrap<sys_mlock>(),
-  wrap<sys_munlock>(),
-  wrap<sys_undelete>(),
-  wrap<sys_futimes>(),
-  wrap<sys_getpgid>(),
-  wrap<nosys>(),
-  wrap<sys_poll>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys___semctl>(),
-  wrap<sys_semget>(),
-  wrap<sys_semop>(),
-  wrap<nosys>(),
-  wrap<sys_msgctl>(),
-  wrap<sys_msgget>(),
-  wrap<sys_msgsnd>(),
-  wrap<sys_msgrcv>(),
-  wrap<sys_shmat>(),
-  wrap<sys_shmctl>(),
-  wrap<sys_shmdt>(),
-  wrap<sys_shmget>(),
-  wrap<sys_clock_gettime>(),
-  wrap<sys_clock_settime>(),
-  wrap<sys_clock_getres>(),
-  wrap<sys_ktimer_create>(),
-  wrap<sys_ktimer_delete>(),
-  wrap<sys_ktimer_settime>(),
-  wrap<sys_ktimer_gettime>(),
-  wrap<sys_ktimer_getoverrun>(),
-  wrap<sys_nanosleep>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_ntp_gettime>(),
-  wrap<nosys>(),
-  wrap<sys_minherit>(),
-  wrap<sys_rfork>(),
-  wrap<sys_openbsd_poll>(),
-  wrap<sys_issetugid>(),
-  wrap<sys_lchown>(),
-  wrap<sys_aio_read>(),
-  wrap<sys_aio_write>(),
-  wrap<sys_lio_listio>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_getdents>(),
-  wrap<nosys>(),
-  wrap<sys_lchmod>(),
-  wrap<sys_lchown>(),
-  wrap<sys_lutimes>(),
-  wrap<sys_msync>(),
-  wrap<sys_nstat>(),
-  wrap<sys_nfstat>(),
-  wrap<sys_nlstat>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_preadv>(),
-  wrap<sys_pwritev>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_fhstatfs>(),
-  wrap<sys_fhopen>(),
-  wrap<sys_fhstat>(),
-  wrap<sys_modnext>(),
-  wrap<sys_modstat>(),
-  wrap<sys_modfnext>(),
-  wrap<sys_modfind>(),
-  wrap<sys_kldload>(),
-  wrap<sys_kldunload>(),
-  wrap<sys_kldfind>(),
-  wrap<sys_kldnext>(),
-  wrap<sys_kldstat>(),
-  wrap<sys_kldfirstmod>(),
-  wrap<sys_getsid>(),
-  wrap<sys_setresuid>(),
-  wrap<sys_setresgid>(),
-  wrap<nosys>(),
-  wrap<sys_aio_return>(),
-  wrap<sys_aio_suspend>(),
-  wrap<sys_aio_cancel>(),
-  wrap<sys_aio_error>(),
-  wrap<sys_oaio_read>(),
-  wrap<sys_oaio_write>(),
-  wrap<sys_olio_listio>(),
-  wrap<sys_yield>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_mlockall>(),
-  wrap<sys_munlockall>(),
-  wrap<sys___getcwd>(),
-  wrap<sys_sched_setparam>(),
-  wrap<sys_sched_getparam>(),
-  wrap<sys_sched_setscheduler>(),
-  wrap<sys_sched_getscheduler>(),
-  wrap<sys_sched_yield>(),
-  wrap<sys_sched_get_priority_max>(),
-  wrap<sys_sched_get_priority_min>(),
-  wrap<sys_sched_rr_get_interval>(),
-  wrap<sys_utrace>(),
-  wrap<sys_sendfile>(),
-  wrap<sys_kldsym>(),
-  wrap<sys_jail>(),
-  wrap<sys_nnpfs_syscall>(),
-  wrap<sys_sigprocmask>(),
-  wrap<sys_sigsuspend>(),
-  wrap<sys_sigaction>(),
-  wrap<sys_sigpending>(),
-  wrap<sys_sigreturn>(),
-  wrap<sys_sigtimedwait>(),
-  wrap<sys_sigwaitinfo>(),
-  wrap<sys___acl_get_file>(),
-  wrap<sys___acl_set_file>(),
-  wrap<sys___acl_get_fd>(),
-  wrap<sys___acl_set_fd>(),
-  wrap<sys___acl_delete_file>(),
-  wrap<sys___acl_delete_fd>(),
-  wrap<sys___acl_aclcheck_file>(),
-  wrap<sys___acl_aclcheck_fd>(),
-  wrap<sys_extattrctl>(),
-  wrap<sys_extattr_set_file>(),
-  wrap<sys_extattr_get_file>(),
-  wrap<sys_extattr_delete_file>(),
-  wrap<sys_aio_waitcomplete>(),
-  wrap<sys_getresuid>(),
-  wrap<sys_getresgid>(),
-  wrap<sys_kqueue>(),
-  wrap<sys_kevent>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_extattr_set_fd>(),
-  wrap<sys_extattr_get_fd>(),
-  wrap<sys_extattr_delete_fd>(),
-  wrap<sys___setugid>(),
-  wrap<nosys>(),
-  wrap<sys_eaccess>(),
-  wrap<sys_afs3_syscall>(),
-  wrap<sys_nmount>(),
-  wrap<sys_mtypeprotect>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys___mac_get_proc>(),
-  wrap<sys___mac_set_proc>(),
-  wrap<sys___mac_get_fd>(),
-  wrap<sys___mac_get_file>(),
-  wrap<sys___mac_set_fd>(),
-  wrap<sys___mac_set_file>(),
-  wrap<sys_kenv>(),
-  wrap<sys_lchflags>(),
-  wrap<sys_uuidgen>(),
-  wrap<sys_sendfile>(),
-  wrap<sys_mac_syscall>(),
-  wrap<sys_getfsstat>(),
-  wrap<sys_statfs>(),
-  wrap<sys_fstatfs>(),
-  wrap<sys_fhstatfs>(),
-  wrap<nosys>(),
-  wrap<sys_ksem_close>(),
-  wrap<sys_ksem_post>(),
-  wrap<sys_ksem_wait>(),
-  wrap<sys_ksem_trywait>(),
-  wrap<sys_ksem_init>(),
-  wrap<sys_ksem_open>(),
-  wrap<sys_ksem_unlink>(),
-  wrap<sys_ksem_getvalue>(),
-  wrap<sys_ksem_destroy>(),
-  wrap<sys___mac_get_pid>(),
-  wrap<sys___mac_get_link>(),
-  wrap<sys___mac_set_link>(),
-  wrap<sys_extattr_set_link>(),
-  wrap<sys_extattr_get_link>(),
-  wrap<sys_extattr_delete_link>(),
-  wrap<sys___mac_execve>(),
-  wrap<sys_sigaction>(),
-  wrap<sys_sigreturn>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_getcontext>(),
-  wrap<sys_setcontext>(),
-  wrap<sys_swapcontext>(),
-  wrap<sys_swapoff>(),
-  wrap<sys___acl_get_link>(),
-  wrap<sys___acl_set_link>(),
-  wrap<sys___acl_delete_link>(),
-  wrap<sys___acl_aclcheck_link>(),
-  wrap<sys_sigwait>(),
-  wrap<sys_thr_create>(),
-  wrap<sys_thr_exit>(),
-  wrap<sys_thr_self>(),
-  wrap<sys_thr_kill>(),
-  wrap<sys__umtx_lock>(),
-  wrap<sys__umtx_unlock>(),
-  wrap<sys_jail_attach>(),
-  wrap<sys_extattr_list_fd>(),
-  wrap<sys_extattr_list_file>(),
-  wrap<sys_extattr_list_link>(),
-  wrap<nosys>(),
-  wrap<sys_ksem_timedwait>(),
-  wrap<sys_thr_suspend>(),
-  wrap<sys_thr_wake>(),
-  wrap<sys_kldunloadf>(),
-  wrap<sys_audit>(),
-  wrap<sys_auditon>(),
-  wrap<sys_getauid>(),
-  wrap<sys_setauid>(),
-  wrap<sys_getaudit>(),
-  wrap<sys_setaudit>(),
-  wrap<sys_getaudit_addr>(),
-  wrap<sys_setaudit_addr>(),
-  wrap<sys_auditctl>(),
-  wrap<sys__umtx_op>(),
-  wrap<sys_thr_new>(),
-  wrap<sys_sigqueue>(),
-  wrap<sys_kmq_open>(),
-  wrap<sys_kmq_setattr>(),
-  wrap<sys_kmq_timedreceive>(),
-  wrap<sys_kmq_timedsend>(),
-  wrap<sys_kmq_notify>(),
-  wrap<sys_kmq_unlink>(),
-  wrap<sys_abort2>(),
-  wrap<sys_thr_set_name>(),
-  wrap<sys_aio_fsync>(),
-  wrap<sys_rtprio_thread>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<nosys>(),
-  wrap<sys_sctp_peeloff>(),
-  wrap<sys_sctp_generic_sendmsg>(),
-  wrap<sys_sctp_generic_sendmsg_iov>(),
-  wrap<sys_sctp_generic_recvmsg>(),
-  wrap<sys_pread>(),
-  wrap<sys_pwrite>(),
-  wrap<sys_mmap>(),
-  wrap<sys_lseek>(),
-  wrap<sys_truncate>(),
-  wrap<sys_ftruncate>(),
-  wrap<sys_thr_kill2>(),
-  wrap<sys_shm_open>(),
-  wrap<sys_shm_unlink>(),
-  wrap<sys_cpuset>(),
-  wrap<sys_cpuset_setid>(),
-  wrap<sys_cpuset_getid>(),
-  wrap<sys_cpuset_getaffinity>(),
-  wrap<sys_cpuset_setaffinity>(),
-  wrap<sys_faccessat>(),
-  wrap<sys_fchmodat>(),
-  wrap<sys_fchownat>(),
-  wrap<sys_fexecve>(),
-  wrap<sys_fstatat>(),
-  wrap<sys_futimesat>(),
-  wrap<sys_linkat>(),
-  wrap<sys_mkdirat>(),
-  wrap<sys_mkfifoat>(),
-  wrap<sys_mknodat>(),
-  wrap<sys_openat>(),
-  wrap<sys_readlinkat>(),
-  wrap<sys_renameat>(),
-  wrap<sys_symlinkat>(),
-  wrap<sys_unlinkat>(),
-  wrap<sys_posix_openpt>(),
-  wrap<sys_gssd_syscall>(),
-  wrap<sys_jail_get>(),
-  wrap<sys_jail_set>(),
-  wrap<sys_jail_remove>(),
-  wrap<sys_closefrom>(),
-  wrap<sys___semctl>(),
-  wrap<sys_msgctl>(),
-  wrap<sys_shmctl>(),
-  wrap<sys_lpathconf>(),
-  wrap<sys_cap_new>(),
-  wrap<sys_cap_getrights>(),
-  wrap<sys_cap_enter>(),
-  wrap<sys_cap_getmode>(),
-  wrap<sys_pdfork>(),
-  wrap<sys_pdkill>(),
-  wrap<sys_pdgetpid>(),
-  wrap<nosys>(),
-  wrap<sys_pselect>(),
-  wrap<sys_getloginclass>(),
-  wrap<sys_setloginclass>(),
-  wrap<sys_rctl_get_racct>(),
-  wrap<sys_rctl_get_rules>(),
-  wrap<sys_rctl_get_limits>(),
-  wrap<sys_rctl_add_rule>(),
-  wrap<sys_rctl_remove_rule>(),
-  wrap<sys_posix_fallocate>(),
-  wrap<sys_posix_fadvise>(),
-  wrap<sys_regmgr_call>(),
-  wrap<sys_jitshm_create>(),
-  wrap<sys_jitshm_alias>(),
-  wrap<sys_dl_get_list>(),
-  wrap<sys_dl_get_info>(),
-  wrap<sys_dl_notify_event>(),
-  wrap<sys_evf_create>(),
-  wrap<sys_evf_delete>(),
-  wrap<sys_evf_open>(),
-  wrap<sys_evf_close>(),
-  wrap<sys_evf_wait>(),
-  wrap<sys_evf_trywait>(),
-  wrap<sys_evf_set>(),
-  wrap<sys_evf_clear>(),
-  wrap<sys_evf_cancel>(),
-  wrap<sys_query_memory_protection>(),
-  wrap<sys_batch_map>(),
-  wrap<sys_osem_create>(),
-  wrap<sys_osem_delete>(),
-  wrap<sys_osem_open>(),
-  wrap<sys_osem_close>(),
-  wrap<sys_osem_wait>(),
-  wrap<sys_osem_trywait>(),
-  wrap<sys_osem_post>(),
-  wrap<sys_osem_cancel>(),
-  wrap<sys_namedobj_create>(),
-  wrap<sys_namedobj_delete>(),
-  wrap<sys_set_vm_container>(),
-  wrap<sys_debug_init>(),
-  wrap<sys_suspend_process>(),
-  wrap<sys_resume_process>(),
-  wrap<sys_opmc_enable>(),
-  wrap<sys_opmc_disable>(),
-  wrap<sys_opmc_set_ctl>(),
-  wrap<sys_opmc_set_ctr>(),
-  wrap<sys_opmc_get_ctr>(),
-  wrap<sys_budget_create>(),
-  wrap<sys_budget_delete>(),
-  wrap<sys_budget_get>(),
-  wrap<sys_budget_set>(),
-  wrap<sys_virtual_query>(),
-  wrap<sys_mdbg_call>(),
-  wrap<sys_obs_sblock_create>(),
-  wrap<sys_obs_sblock_delete>(),
-  wrap<sys_obs_sblock_enter>(),
-  wrap<sys_obs_sblock_exit>(),
-  wrap<sys_obs_sblock_xenter>(),
-  wrap<sys_obs_sblock_xexit>(),
-  wrap<sys_obs_eport_create>(),
-  wrap<sys_obs_eport_delete>(),
-  wrap<sys_obs_eport_trigger>(),
-  wrap<sys_obs_eport_open>(),
-  wrap<sys_obs_eport_close>(),
-  wrap<sys_is_in_sandbox>(),
-  wrap<sys_dmem_container>(),
-  wrap<sys_get_authinfo>(),
-  wrap<sys_mname>(),
-  wrap<sys_dynlib_dlopen>(),
-  wrap<sys_dynlib_dlclose>(),
-  wrap<sys_dynlib_dlsym>(),
-  wrap<sys_dynlib_get_list>(),
-  wrap<sys_dynlib_get_info>(),
-  wrap<sys_dynlib_load_prx>(),
-  wrap<sys_dynlib_unload_prx>(),
-  wrap<sys_dynlib_do_copy_relocations>(),
-  wrap<sys_dynlib_prepare_dlclose>(),
-  wrap<sys_dynlib_get_proc_param>(),
-  wrap<sys_dynlib_process_needed_and_relocate>(),
-  wrap<sys_sandbox_path>(),
-  wrap<sys_mdbg_service>(),
-  wrap<sys_randomized_path>(),
-  wrap<sys_rdup>(),
-  wrap<sys_dl_get_metadata>(),
-  wrap<sys_workaround8849>(),
-  wrap<sys_is_development_mode>(),
-  wrap<sys_get_self_auth_info>(),
-  wrap<sys_dynlib_get_info_ex>(),
-  wrap<sys_budget_getid>(),
-  wrap<sys_budget_get_ptype>(),
-  wrap<sys_get_paging_stats_of_all_threads>(),
-  wrap<sys_get_proc_type_info>(),
-  wrap<sys_get_resident_count>(),
-  wrap<sys_prepare_to_suspend_process>(),
-  wrap<sys_get_resident_fmem_count>(),
-  wrap<sys_thr_get_name>(),
-  wrap<sys_set_gpo>(),
-  wrap<sys_get_paging_stats_of_all_objects>(),
-  wrap<sys_test_debug_rwmem>(),
-  wrap<sys_free_stack>(),
-  wrap<sys_suspend_system>(),
-  wrap<sys_ipmimgr_call>(),
-  wrap<sys_get_gpo>(),
-  wrap<sys_get_vm_map_timestamp>(),
-  wrap<sys_opmc_set_hw>(),
-  wrap<sys_opmc_get_hw>(),
-  wrap<sys_get_cpu_usage_all>(),
-  wrap<sys_mmap_dmem>(),
-  wrap<sys_physhm_open>(),
-  wrap<sys_physhm_unlink>(),
-  wrap<sys_resume_internal_hdd>(),
-  wrap<sys_thr_suspend_ucontext>(),
-  wrap<sys_thr_resume_ucontext>(),
-  wrap<sys_thr_get_ucontext>(),
-  wrap<sys_thr_set_ucontext>(),
-  wrap<sys_set_timezone_info>(),
-  wrap<sys_set_phys_fmem_limit>(),
-  wrap<sys_utc_to_localtime>(),
-  wrap<sys_localtime_to_utc>(),
-  wrap<sys_set_uevt>(),
-  wrap<sys_get_cpu_usage_proc>(),
-  wrap<sys_get_map_statistics>(),
-  wrap<sys_set_chicken_switches>(),
-  wrap<sys_extend_page_table_pool>(),
-  wrap<sys_extend_page_table_pool2>(),
-  wrap<sys_get_kernel_mem_statistics>(),
-  wrap<sys_get_sdk_compiled_version>(),
-  wrap<sys_app_state_change>(),
-  wrap<sys_dynlib_get_obj_member>(),
-  wrap<sys_budget_get_ptype_of_budget>(),
-  wrap<sys_prepare_to_resume_process>(),
-  wrap<sys_process_terminate>(),
-  wrap<sys_blockpool_open>(),
-  wrap<sys_blockpool_map>(),
-  wrap<sys_blockpool_unmap>(),
-  wrap<sys_dynlib_get_info_for_libdbg>(),
-  wrap<sys_blockpool_batch>(),
-  wrap<sys_fdatasync>(),
-  wrap<sys_dynlib_get_list2>(),
-  wrap<sys_dynlib_get_info2>(),
-  wrap<sys_aio_submit>(),
-  wrap<sys_aio_multi_delete>(),
-  wrap<sys_aio_multi_wait>(),
-  wrap<sys_aio_multi_poll>(),
-  wrap<sys_aio_get_data>(),
-  wrap<sys_aio_multi_cancel>(),
-  wrap<sys_get_bio_usage_all>(),
-  wrap<sys_aio_create>(),
-  wrap<sys_aio_submit_cmd>(),
-  wrap<sys_aio_init>(),
-  wrap<sys_get_page_table_stats>(),
-  wrap<sys_dynlib_get_list_for_libdbg>(),
-  wrap<sys_blockpool_move>(),
-  wrap<sys_virtual_query_all>(),
-  wrap<sys_reserve_2mb_page>(),
-  wrap<sys_cpumode_yield>(),
+    wrap<nosys>(),
+    wrap<sys_exit>(),
+    wrap<sys_fork>(),
+    wrap<sys_read>(),
+    wrap<sys_write>(),
+    wrap<sys_open>(),
+    wrap<sys_close>(),
+    wrap<sys_wait4>(),
+    wrap<nosys>(),
+    wrap<sys_link>(),
+    wrap<sys_unlink>(),
+    wrap<nosys>(),
+    wrap<sys_chdir>(),
+    wrap<sys_fchdir>(),
+    wrap<sys_mknod>(),
+    wrap<sys_chmod>(),
+    wrap<sys_chown>(),
+    wrap<sys_obreak>(),
+    wrap<sys_getfsstat>(),
+    wrap<nosys>(),
+    wrap<sys_getpid>(),
+    wrap<sys_mount>(),
+    wrap<sys_unmount>(),
+    wrap<sys_setuid>(),
+    wrap<sys_getuid>(),
+    wrap<sys_geteuid>(),
+    wrap<sys_ptrace>(),
+    wrap<sys_recvmsg>(),
+    wrap<sys_sendmsg>(),
+    wrap<sys_recvfrom>(),
+    wrap<sys_accept>(),
+    wrap<sys_getpeername>(),
+    wrap<sys_getsockname>(),
+    wrap<sys_access>(),
+    wrap<sys_chflags>(),
+    wrap<sys_fchflags>(),
+    wrap<sys_sync>(),
+    wrap<sys_kill>(),
+    wrap<nosys>(),
+    wrap<sys_getppid>(),
+    wrap<nosys>(),
+    wrap<sys_dup>(),
+    wrap<sys_pipe>(),
+    wrap<sys_getegid>(),
+    wrap<sys_profil>(),
+    wrap<sys_ktrace>(),
+    wrap<nosys>(),
+    wrap<sys_getgid>(),
+    wrap<nosys>(),
+    wrap<sys_getlogin>(),
+    wrap<sys_setlogin>(),
+    wrap<sys_acct>(),
+    wrap<nosys>(),
+    wrap<sys_sigaltstack>(),
+    wrap<sys_ioctl>(),
+    wrap<sys_reboot>(),
+    wrap<sys_revoke>(),
+    wrap<sys_symlink>(),
+    wrap<sys_readlink>(),
+    wrap<sys_execve>(),
+    wrap<sys_umask>(),
+    wrap<sys_chroot>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_msync>(),
+    wrap<sys_vfork>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_sbrk>(),
+    wrap<sys_sstk>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_munmap>(),
+    wrap<sys_mprotect>(),
+    wrap<sys_madvise>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_mincore>(),
+    wrap<sys_getgroups>(),
+    wrap<sys_setgroups>(),
+    wrap<sys_getpgrp>(),
+    wrap<sys_setpgid>(),
+    wrap<sys_setitimer>(),
+    wrap<nosys>(),
+    wrap<sys_swapon>(),
+    wrap<sys_getitimer>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_getdtablesize>(),
+    wrap<sys_dup2>(),
+    wrap<nosys>(),
+    wrap<sys_fcntl>(),
+    wrap<sys_select>(),
+    wrap<nosys>(),
+    wrap<sys_fsync>(),
+    wrap<sys_setpriority>(),
+    wrap<sys_socket>(),
+    wrap<sys_connect>(),
+    wrap<sys_netcontrol>(),
+    wrap<sys_getpriority>(),
+    wrap<sys_netabort>(),
+    wrap<sys_netgetsockinfo>(),
+    wrap<nosys>(),
+    wrap<sys_bind>(),
+    wrap<sys_setsockopt>(),
+    wrap<sys_listen>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_socketex>(),
+    wrap<sys_socketclose>(),
+    wrap<nosys>(),
+    wrap<sys_gettimeofday>(),
+    wrap<sys_getrusage>(),
+    wrap<sys_getsockopt>(),
+    wrap<nosys>(),
+    wrap<sys_readv>(),
+    wrap<sys_writev>(),
+    wrap<sys_settimeofday>(),
+    wrap<sys_fchown>(),
+    wrap<sys_fchmod>(),
+    wrap<sys_netgetiflist>(),
+    wrap<sys_setreuid>(),
+    wrap<sys_setregid>(),
+    wrap<sys_rename>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_flock>(),
+    wrap<sys_mkfifo>(),
+    wrap<sys_sendto>(),
+    wrap<sys_shutdown>(),
+    wrap<sys_socketpair>(),
+    wrap<sys_mkdir>(),
+    wrap<sys_rmdir>(),
+    wrap<sys_utimes>(),
+    wrap<nosys>(),
+    wrap<sys_adjtime>(),
+    wrap<sys_kqueueex>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_setsid>(),
+    wrap<sys_quotactl>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_nlm_syscall>(),
+    wrap<sys_nfssvc>(),
+    wrap<nosys>(),
+    wrap<sys_statfs>(),
+    wrap<sys_fstatfs>(),
+    wrap<nosys>(),
+    wrap<sys_lgetfh>(),
+    wrap<sys_getfh>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_sysarch>(),
+    wrap<sys_rtprio>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_semsys>(),
+    wrap<sys_msgsys>(),
+    wrap<sys_shmsys>(),
+    wrap<nosys>(),
+    wrap<sys_freebsd6_pread>(),
+    wrap<sys_freebsd6_pwrite>(),
+    wrap<sys_setfib>(),
+    wrap<sys_ntp_adjtime>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_setgid>(),
+    wrap<sys_setegid>(),
+    wrap<sys_seteuid>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_stat>(),
+    wrap<sys_fstat>(),
+    wrap<sys_lstat>(),
+    wrap<sys_pathconf>(),
+    wrap<sys_fpathconf>(),
+    wrap<nosys>(),
+    wrap<sys_getrlimit>(),
+    wrap<sys_setrlimit>(),
+    wrap<sys_getdirentries>(),
+    wrap<sys_freebsd6_mmap>(),
+    wrap<nosys>(),
+    wrap<sys_freebsd6_lseek>(),
+    wrap<sys_freebsd6_truncate>(),
+    wrap<sys_freebsd6_ftruncate>(),
+    wrap<sys___sysctl>(),
+    wrap<sys_mlock>(),
+    wrap<sys_munlock>(),
+    wrap<sys_undelete>(),
+    wrap<sys_futimes>(),
+    wrap<sys_getpgid>(),
+    wrap<nosys>(),
+    wrap<sys_poll>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys___semctl>(),
+    wrap<sys_semget>(),
+    wrap<sys_semop>(),
+    wrap<nosys>(),
+    wrap<sys_msgctl>(),
+    wrap<sys_msgget>(),
+    wrap<sys_msgsnd>(),
+    wrap<sys_msgrcv>(),
+    wrap<sys_shmat>(),
+    wrap<sys_shmctl>(),
+    wrap<sys_shmdt>(),
+    wrap<sys_shmget>(),
+    wrap<sys_clock_gettime>(),
+    wrap<sys_clock_settime>(),
+    wrap<sys_clock_getres>(),
+    wrap<sys_ktimer_create>(),
+    wrap<sys_ktimer_delete>(),
+    wrap<sys_ktimer_settime>(),
+    wrap<sys_ktimer_gettime>(),
+    wrap<sys_ktimer_getoverrun>(),
+    wrap<sys_nanosleep>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_ntp_gettime>(),
+    wrap<nosys>(),
+    wrap<sys_minherit>(),
+    wrap<sys_rfork>(),
+    wrap<sys_openbsd_poll>(),
+    wrap<sys_issetugid>(),
+    wrap<sys_lchown>(),
+    wrap<sys_aio_read>(),
+    wrap<sys_aio_write>(),
+    wrap<sys_lio_listio>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_getdents>(),
+    wrap<nosys>(),
+    wrap<sys_lchmod>(),
+    wrap<sys_lchown>(),
+    wrap<sys_lutimes>(),
+    wrap<sys_msync>(),
+    wrap<sys_nstat>(),
+    wrap<sys_nfstat>(),
+    wrap<sys_nlstat>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_preadv>(),
+    wrap<sys_pwritev>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_fhstatfs>(),
+    wrap<sys_fhopen>(),
+    wrap<sys_fhstat>(),
+    wrap<sys_modnext>(),
+    wrap<sys_modstat>(),
+    wrap<sys_modfnext>(),
+    wrap<sys_modfind>(),
+    wrap<sys_kldload>(),
+    wrap<sys_kldunload>(),
+    wrap<sys_kldfind>(),
+    wrap<sys_kldnext>(),
+    wrap<sys_kldstat>(),
+    wrap<sys_kldfirstmod>(),
+    wrap<sys_getsid>(),
+    wrap<sys_setresuid>(),
+    wrap<sys_setresgid>(),
+    wrap<nosys>(),
+    wrap<sys_aio_return>(),
+    wrap<sys_aio_suspend>(),
+    wrap<sys_aio_cancel>(),
+    wrap<sys_aio_error>(),
+    wrap<sys_oaio_read>(),
+    wrap<sys_oaio_write>(),
+    wrap<sys_olio_listio>(),
+    wrap<sys_yield>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_mlockall>(),
+    wrap<sys_munlockall>(),
+    wrap<sys___getcwd>(),
+    wrap<sys_sched_setparam>(),
+    wrap<sys_sched_getparam>(),
+    wrap<sys_sched_setscheduler>(),
+    wrap<sys_sched_getscheduler>(),
+    wrap<sys_sched_yield>(),
+    wrap<sys_sched_get_priority_max>(),
+    wrap<sys_sched_get_priority_min>(),
+    wrap<sys_sched_rr_get_interval>(),
+    wrap<sys_utrace>(),
+    wrap<sys_sendfile>(),
+    wrap<sys_kldsym>(),
+    wrap<sys_jail>(),
+    wrap<sys_nnpfs_syscall>(),
+    wrap<sys_sigprocmask>(),
+    wrap<sys_sigsuspend>(),
+    wrap<sys_sigaction>(),
+    wrap<sys_sigpending>(),
+    wrap<sys_sigreturn>(),
+    wrap<sys_sigtimedwait>(),
+    wrap<sys_sigwaitinfo>(),
+    wrap<sys___acl_get_file>(),
+    wrap<sys___acl_set_file>(),
+    wrap<sys___acl_get_fd>(),
+    wrap<sys___acl_set_fd>(),
+    wrap<sys___acl_delete_file>(),
+    wrap<sys___acl_delete_fd>(),
+    wrap<sys___acl_aclcheck_file>(),
+    wrap<sys___acl_aclcheck_fd>(),
+    wrap<sys_extattrctl>(),
+    wrap<sys_extattr_set_file>(),
+    wrap<sys_extattr_get_file>(),
+    wrap<sys_extattr_delete_file>(),
+    wrap<sys_aio_waitcomplete>(),
+    wrap<sys_getresuid>(),
+    wrap<sys_getresgid>(),
+    wrap<sys_kqueue>(),
+    wrap<sys_kevent>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_extattr_set_fd>(),
+    wrap<sys_extattr_get_fd>(),
+    wrap<sys_extattr_delete_fd>(),
+    wrap<sys___setugid>(),
+    wrap<nosys>(),
+    wrap<sys_eaccess>(),
+    wrap<sys_afs3_syscall>(),
+    wrap<sys_nmount>(),
+    wrap<sys_mtypeprotect>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys___mac_get_proc>(),
+    wrap<sys___mac_set_proc>(),
+    wrap<sys___mac_get_fd>(),
+    wrap<sys___mac_get_file>(),
+    wrap<sys___mac_set_fd>(),
+    wrap<sys___mac_set_file>(),
+    wrap<sys_kenv>(),
+    wrap<sys_lchflags>(),
+    wrap<sys_uuidgen>(),
+    wrap<sys_sendfile>(),
+    wrap<sys_mac_syscall>(),
+    wrap<sys_getfsstat>(),
+    wrap<sys_statfs>(),
+    wrap<sys_fstatfs>(),
+    wrap<sys_fhstatfs>(),
+    wrap<nosys>(),
+    wrap<sys_ksem_close>(),
+    wrap<sys_ksem_post>(),
+    wrap<sys_ksem_wait>(),
+    wrap<sys_ksem_trywait>(),
+    wrap<sys_ksem_init>(),
+    wrap<sys_ksem_open>(),
+    wrap<sys_ksem_unlink>(),
+    wrap<sys_ksem_getvalue>(),
+    wrap<sys_ksem_destroy>(),
+    wrap<sys___mac_get_pid>(),
+    wrap<sys___mac_get_link>(),
+    wrap<sys___mac_set_link>(),
+    wrap<sys_extattr_set_link>(),
+    wrap<sys_extattr_get_link>(),
+    wrap<sys_extattr_delete_link>(),
+    wrap<sys___mac_execve>(),
+    wrap<sys_sigaction>(),
+    wrap<sys_sigreturn>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_getcontext>(),
+    wrap<sys_setcontext>(),
+    wrap<sys_swapcontext>(),
+    wrap<sys_swapoff>(),
+    wrap<sys___acl_get_link>(),
+    wrap<sys___acl_set_link>(),
+    wrap<sys___acl_delete_link>(),
+    wrap<sys___acl_aclcheck_link>(),
+    wrap<sys_sigwait>(),
+    wrap<sys_thr_create>(),
+    wrap<sys_thr_exit>(),
+    wrap<sys_thr_self>(),
+    wrap<sys_thr_kill>(),
+    wrap<sys__umtx_lock>(),
+    wrap<sys__umtx_unlock>(),
+    wrap<sys_jail_attach>(),
+    wrap<sys_extattr_list_fd>(),
+    wrap<sys_extattr_list_file>(),
+    wrap<sys_extattr_list_link>(),
+    wrap<nosys>(),
+    wrap<sys_ksem_timedwait>(),
+    wrap<sys_thr_suspend>(),
+    wrap<sys_thr_wake>(),
+    wrap<sys_kldunloadf>(),
+    wrap<sys_audit>(),
+    wrap<sys_auditon>(),
+    wrap<sys_getauid>(),
+    wrap<sys_setauid>(),
+    wrap<sys_getaudit>(),
+    wrap<sys_setaudit>(),
+    wrap<sys_getaudit_addr>(),
+    wrap<sys_setaudit_addr>(),
+    wrap<sys_auditctl>(),
+    wrap<sys__umtx_op>(),
+    wrap<sys_thr_new>(),
+    wrap<sys_sigqueue>(),
+    wrap<sys_kmq_open>(),
+    wrap<sys_kmq_setattr>(),
+    wrap<sys_kmq_timedreceive>(),
+    wrap<sys_kmq_timedsend>(),
+    wrap<sys_kmq_notify>(),
+    wrap<sys_kmq_unlink>(),
+    wrap<sys_abort2>(),
+    wrap<sys_thr_set_name>(),
+    wrap<sys_aio_fsync>(),
+    wrap<sys_rtprio_thread>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<nosys>(),
+    wrap<sys_sctp_peeloff>(),
+    wrap<sys_sctp_generic_sendmsg>(),
+    wrap<sys_sctp_generic_sendmsg_iov>(),
+    wrap<sys_sctp_generic_recvmsg>(),
+    wrap<sys_pread>(),
+    wrap<sys_pwrite>(),
+    wrap<sys_mmap>(),
+    wrap<sys_lseek>(),
+    wrap<sys_truncate>(),
+    wrap<sys_ftruncate>(),
+    wrap<sys_thr_kill2>(),
+    wrap<sys_shm_open>(),
+    wrap<sys_shm_unlink>(),
+    wrap<sys_cpuset>(),
+    wrap<sys_cpuset_setid>(),
+    wrap<sys_cpuset_getid>(),
+    wrap<sys_cpuset_getaffinity>(),
+    wrap<sys_cpuset_setaffinity>(),
+    wrap<sys_faccessat>(),
+    wrap<sys_fchmodat>(),
+    wrap<sys_fchownat>(),
+    wrap<sys_fexecve>(),
+    wrap<sys_fstatat>(),
+    wrap<sys_futimesat>(),
+    wrap<sys_linkat>(),
+    wrap<sys_mkdirat>(),
+    wrap<sys_mkfifoat>(),
+    wrap<sys_mknodat>(),
+    wrap<sys_openat>(),
+    wrap<sys_readlinkat>(),
+    wrap<sys_renameat>(),
+    wrap<sys_symlinkat>(),
+    wrap<sys_unlinkat>(),
+    wrap<sys_posix_openpt>(),
+    wrap<sys_gssd_syscall>(),
+    wrap<sys_jail_get>(),
+    wrap<sys_jail_set>(),
+    wrap<sys_jail_remove>(),
+    wrap<sys_closefrom>(),
+    wrap<sys___semctl>(),
+    wrap<sys_msgctl>(),
+    wrap<sys_shmctl>(),
+    wrap<sys_lpathconf>(),
+    wrap<sys_cap_new>(),
+    wrap<sys_cap_getrights>(),
+    wrap<sys_cap_enter>(),
+    wrap<sys_cap_getmode>(),
+    wrap<sys_pdfork>(),
+    wrap<sys_pdkill>(),
+    wrap<sys_pdgetpid>(),
+    wrap<nosys>(),
+    wrap<sys_pselect>(),
+    wrap<sys_getloginclass>(),
+    wrap<sys_setloginclass>(),
+    wrap<sys_rctl_get_racct>(),
+    wrap<sys_rctl_get_rules>(),
+    wrap<sys_rctl_get_limits>(),
+    wrap<sys_rctl_add_rule>(),
+    wrap<sys_rctl_remove_rule>(),
+    wrap<sys_posix_fallocate>(),
+    wrap<sys_posix_fadvise>(),
+    wrap<sys_regmgr_call>(),
+    wrap<sys_jitshm_create>(),
+    wrap<sys_jitshm_alias>(),
+    wrap<sys_dl_get_list>(),
+    wrap<sys_dl_get_info>(),
+    wrap<sys_dl_notify_event>(),
+    wrap<sys_evf_create>(),
+    wrap<sys_evf_delete>(),
+    wrap<sys_evf_open>(),
+    wrap<sys_evf_close>(),
+    wrap<sys_evf_wait>(),
+    wrap<sys_evf_trywait>(),
+    wrap<sys_evf_set>(),
+    wrap<sys_evf_clear>(),
+    wrap<sys_evf_cancel>(),
+    wrap<sys_query_memory_protection>(),
+    wrap<sys_batch_map>(),
+    wrap<sys_osem_create>(),
+    wrap<sys_osem_delete>(),
+    wrap<sys_osem_open>(),
+    wrap<sys_osem_close>(),
+    wrap<sys_osem_wait>(),
+    wrap<sys_osem_trywait>(),
+    wrap<sys_osem_post>(),
+    wrap<sys_osem_cancel>(),
+    wrap<sys_namedobj_create>(),
+    wrap<sys_namedobj_delete>(),
+    wrap<sys_set_vm_container>(),
+    wrap<sys_debug_init>(),
+    wrap<sys_suspend_process>(),
+    wrap<sys_resume_process>(),
+    wrap<sys_opmc_enable>(),
+    wrap<sys_opmc_disable>(),
+    wrap<sys_opmc_set_ctl>(),
+    wrap<sys_opmc_set_ctr>(),
+    wrap<sys_opmc_get_ctr>(),
+    wrap<sys_budget_create>(),
+    wrap<sys_budget_delete>(),
+    wrap<sys_budget_get>(),
+    wrap<sys_budget_set>(),
+    wrap<sys_virtual_query>(),
+    wrap<sys_mdbg_call>(),
+    wrap<sys_obs_sblock_create>(),
+    wrap<sys_obs_sblock_delete>(),
+    wrap<sys_obs_sblock_enter>(),
+    wrap<sys_obs_sblock_exit>(),
+    wrap<sys_obs_sblock_xenter>(),
+    wrap<sys_obs_sblock_xexit>(),
+    wrap<sys_obs_eport_create>(),
+    wrap<sys_obs_eport_delete>(),
+    wrap<sys_obs_eport_trigger>(),
+    wrap<sys_obs_eport_open>(),
+    wrap<sys_obs_eport_close>(),
+    wrap<sys_is_in_sandbox>(),
+    wrap<sys_dmem_container>(),
+    wrap<sys_get_authinfo>(),
+    wrap<sys_mname>(),
+    wrap<sys_dynlib_dlopen>(),
+    wrap<sys_dynlib_dlclose>(),
+    wrap<sys_dynlib_dlsym>(),
+    wrap<sys_dynlib_get_list>(),
+    wrap<sys_dynlib_get_info>(),
+    wrap<sys_dynlib_load_prx>(),
+    wrap<sys_dynlib_unload_prx>(),
+    wrap<sys_dynlib_do_copy_relocations>(),
+    wrap<sys_dynlib_prepare_dlclose>(),
+    wrap<sys_dynlib_get_proc_param>(),
+    wrap<sys_dynlib_process_needed_and_relocate>(),
+    wrap<sys_sandbox_path>(),
+    wrap<sys_mdbg_service>(),
+    wrap<sys_randomized_path>(),
+    wrap<sys_rdup>(),
+    wrap<sys_dl_get_metadata>(),
+    wrap<sys_workaround8849>(),
+    wrap<sys_is_development_mode>(),
+    wrap<sys_get_self_auth_info>(),
+    wrap<sys_dynlib_get_info_ex>(),
+    wrap<sys_budget_getid>(),
+    wrap<sys_budget_get_ptype>(),
+    wrap<sys_get_paging_stats_of_all_threads>(),
+    wrap<sys_get_proc_type_info>(),
+    wrap<sys_get_resident_count>(),
+    wrap<sys_prepare_to_suspend_process>(),
+    wrap<sys_get_resident_fmem_count>(),
+    wrap<sys_thr_get_name>(),
+    wrap<sys_set_gpo>(),
+    wrap<sys_get_paging_stats_of_all_objects>(),
+    wrap<sys_test_debug_rwmem>(),
+    wrap<sys_free_stack>(),
+    wrap<sys_suspend_system>(),
+    wrap<sys_ipmimgr_call>(),
+    wrap<sys_get_gpo>(),
+    wrap<sys_get_vm_map_timestamp>(),
+    wrap<sys_opmc_set_hw>(),
+    wrap<sys_opmc_get_hw>(),
+    wrap<sys_get_cpu_usage_all>(),
+    wrap<sys_mmap_dmem>(),
+    wrap<sys_physhm_open>(),
+    wrap<sys_physhm_unlink>(),
+    wrap<sys_resume_internal_hdd>(),
+    wrap<sys_thr_suspend_ucontext>(),
+    wrap<sys_thr_resume_ucontext>(),
+    wrap<sys_thr_get_ucontext>(),
+    wrap<sys_thr_set_ucontext>(),
+    wrap<sys_set_timezone_info>(),
+    wrap<sys_set_phys_fmem_limit>(),
+    wrap<sys_utc_to_localtime>(),
+    wrap<sys_localtime_to_utc>(),
+    wrap<sys_set_uevt>(),
+    wrap<sys_get_cpu_usage_proc>(),
+    wrap<sys_get_map_statistics>(),
+    wrap<sys_set_chicken_switches>(),
+    wrap<sys_extend_page_table_pool>(),
+    wrap<sys_extend_page_table_pool2>(),
+    wrap<sys_get_kernel_mem_statistics>(),
+    wrap<sys_get_sdk_compiled_version>(),
+    wrap<sys_app_state_change>(),
+    wrap<sys_dynlib_get_obj_member>(),
+    wrap<sys_budget_get_ptype_of_budget>(),
+    wrap<sys_prepare_to_resume_process>(),
+    wrap<sys_process_terminate>(),
+    wrap<sys_blockpool_open>(),
+    wrap<sys_blockpool_map>(),
+    wrap<sys_blockpool_unmap>(),
+    wrap<sys_dynlib_get_info_for_libdbg>(),
+    wrap<sys_blockpool_batch>(),
+    wrap<sys_fdatasync>(),
+    wrap<sys_dynlib_get_list2>(),
+    wrap<sys_dynlib_get_info2>(),
+    wrap<sys_aio_submit>(),
+    wrap<sys_aio_multi_delete>(),
+    wrap<sys_aio_multi_wait>(),
+    wrap<sys_aio_multi_poll>(),
+    wrap<sys_aio_get_data>(),
+    wrap<sys_aio_multi_cancel>(),
+    wrap<sys_get_bio_usage_all>(),
+    wrap<sys_aio_create>(),
+    wrap<sys_aio_submit_cmd>(),
+    wrap<sys_aio_init>(),
+    wrap<sys_get_page_table_stats>(),
+    wrap<sys_dynlib_get_list_for_libdbg>(),
+    wrap<sys_blockpool_move>(),
+    wrap<sys_virtual_query_all>(),
+    wrap<sys_reserve_2mb_page>(),
+    wrap<sys_cpumode_yield>(),
 };
 
-constinit sysentvec freebsd9_sysvec = {
-  .size = std::size(freebsd9_sysent),
-  .table = freebsd9_sysent
-};
+constinit sysentvec freebsd9_sysvec = {.size = std::size(freebsd9_sysent),
+                                       .table = freebsd9_sysent};
 
-constinit sysentvec freebsd11_sysvec = {
-  .size = std::size(freebsd11_sysent),
-  .table = freebsd11_sysent
-};
+constinit sysentvec freebsd11_sysvec = {.size = std::size(freebsd11_sysent),
+                                        .table = freebsd11_sysent};
 
-constinit sysentvec ps4_sysvec = {
-  .size = std::size(ps4_sysent),
-  .table = ps4_sysent
-};
+constinit sysentvec ps4_sysvec = {.size = std::size(ps4_sysent),
+                                  .table = ps4_sysent};
 
-constinit sysentvec ps5_sysvec = {
-  .size = 0,
-  .table = nullptr
-};
+constinit sysentvec ps5_sysvec = {.size = 0, .table = nullptr};
 } // namespace orbis
diff --git a/orbis-kernel/src/utils/Logs.cpp b/orbis-kernel/src/utils/Logs.cpp
index 555f2b512..4d80b0176 100644
--- a/orbis-kernel/src/utils/Logs.cpp
+++ b/orbis-kernel/src/utils/Logs.cpp
@@ -1,10 +1,10 @@
 #include "utils/Logs.hpp"
+#include <cstdarg>
+#include <cstdint>
 #include <sstream>
 #include <string>
 #include <string_view>
 #include <vector>
-#include <cstdarg>
-#include <cstdint>
 
 static void append_hex(std::string &out, std::uintmax_t value) {
   std::ostringstream buf;
diff --git a/rpcsx-os/bridge.cpp b/rpcsx-os/bridge.cpp
index 75e750a50..f7e48949e 100644
--- a/rpcsx-os/bridge.cpp
+++ b/rpcsx-os/bridge.cpp
@@ -1,4 +1,3 @@
 #include "bridge.hpp"
 
 amdgpu::bridge::BridgePusher rx::bridge;
-
diff --git a/rpcsx-os/io-device.cpp b/rpcsx-os/io-device.cpp
index f70c20d57..1b306fb35 100644
--- a/rpcsx-os/io-device.cpp
+++ b/rpcsx-os/io-device.cpp
@@ -4,9 +4,7 @@
 #include <string>
 #include <unistd.h>
 
-std::int64_t io_device_instance_close(IoDeviceInstance *instance) {
-  return 0;
-}
+std::int64_t io_device_instance_close(IoDeviceInstance *instance) { return 0; }
 
 void io_device_instance_init(IoDevice *device, IoDeviceInstance *instance) {
   if (instance->device == nullptr) {
@@ -54,7 +52,8 @@ static std::int64_t host_io_device_instance_close(IoDeviceInstance *instance) {
   return io_device_instance_close(instance);
 }
 
-static std::int32_t host_io_open(IoDevice *device, orbis::Ref<IoDeviceInstance> *instance,
+static std::int32_t host_io_open(IoDevice *device,
+                                 orbis::Ref<IoDeviceInstance> *instance,
                                  const char *path, std::uint32_t flags,
                                  std::uint32_t mode) {
   auto hostDevice = static_cast<HostIoDevice *>(device);
@@ -99,7 +98,8 @@ static std::int32_t host_io_open(IoDevice *device, orbis::Ref<IoDeviceInstance>
   }
 
   if (flags != 0) {
-    std::fprintf(stderr, "host_io_open: ***ERROR*** Unhandled open flags %x\n", flags);
+    std::fprintf(stderr, "host_io_open: ***ERROR*** Unhandled open flags %x\n",
+                 flags);
   }
 
   int hostFd = ::open(realPath.c_str(), realFlags, 0777);
diff --git a/rpcsx-os/io-device.hpp b/rpcsx-os/io-device.hpp
index ef1ec2d33..fccdc4a77 100644
--- a/rpcsx-os/io-device.hpp
+++ b/rpcsx-os/io-device.hpp
@@ -49,7 +49,6 @@ struct IoDevice : orbis::RcBase {
                        std::uint32_t mode) = nullptr;
 };
 
-
 std::int64_t io_device_instance_close(IoDeviceInstance *instance);
 void io_device_instance_init(IoDevice *device, IoDeviceInstance *instance);
 
diff --git a/rpcsx-os/iodev/dce.cpp b/rpcsx-os/iodev/dce.cpp
index 5c628a48e..26a585b95 100644
--- a/rpcsx-os/iodev/dce.cpp
+++ b/rpcsx-os/iodev/dce.cpp
@@ -1,11 +1,11 @@
 #include "bridge.hpp"
 #include "io-device.hpp"
 #include "orbis/KernelAllocator.hpp"
+#include "vm.hpp"
 #include <cinttypes>
 #include <cstddef>
 #include <cstdio>
 #include <cstring>
-#include "vm.hpp"
 
 struct VideoOutBuffer {
   std::uint32_t pixelFormat;
@@ -151,7 +151,6 @@ static std::int64_t dce_instance_ioctl(IoDeviceInstance *instance,
     std::fprintf(stderr, "dce: RegisterBuffer(%lx, %lx, %lx, %lx)\n",
                  args->attributeIndex, args->index, args->address, args->unk);
 
-
     if (args->index >= std::size(rx::bridge.header->buffers)) {
       // TODO
       std::fprintf(stderr, "dce: out of buffers!\n");
@@ -160,13 +159,12 @@ static std::int64_t dce_instance_ioctl(IoDeviceInstance *instance,
 
     // TODO: lock bridge header
     rx::bridge.header->buffers[args->index] = {
-      .width = dceInstance->bufferAttributes.width,
-      .height = dceInstance->bufferAttributes.height,
-      .pitch = dceInstance->bufferAttributes.pitch,
-      .address = args->address,
-      .pixelFormat = dceInstance->bufferAttributes.pixelFormat,
-      .tilingMode = dceInstance->bufferAttributes.tilingMode
-    };
+        .width = dceInstance->bufferAttributes.width,
+        .height = dceInstance->bufferAttributes.height,
+        .pitch = dceInstance->bufferAttributes.pitch,
+        .address = args->address,
+        .pixelFormat = dceInstance->bufferAttributes.pixelFormat,
+        .tilingMode = dceInstance->bufferAttributes.tilingMode};
     return 0;
   }
 
@@ -205,13 +203,13 @@ static std::int64_t dce_instance_ioctl(IoDeviceInstance *instance,
         args->arg1, args->displayBufferIndex, args->flipMode, args->flipArg,
         args->arg5, args->arg6, args->arg7, args->arg8);
 
-    rx::bridge.sendFlip(args->displayBufferIndex, /*args->flipMode,*/ args->flipArg);
+    rx::bridge.sendFlip(args->displayBufferIndex,
+                        /*args->flipMode,*/ args->flipArg);
 
     if (args->flipMode == 1 || args->arg7 == 0) {
       // orbis::bridge.sendDoFlip();
     }
 
-
     if (args->displayBufferIndex != -1) {
       if (bufferInUsePtr) {
         auto ptr = bufferInUsePtr + args->displayBufferIndex;
diff --git a/rpcsx-os/iodev/dipsw.cpp b/rpcsx-os/iodev/dipsw.cpp
index 6dbc0d64b..8e7d3e760 100644
--- a/rpcsx-os/iodev/dipsw.cpp
+++ b/rpcsx-os/iodev/dipsw.cpp
@@ -2,11 +2,9 @@
 #include "orbis/KernelAllocator.hpp"
 #include <cstdio>
 
-struct DipswDevice : public IoDevice {
-};
+struct DipswDevice : public IoDevice {};
 
-struct DipswInstance : public IoDeviceInstance {
-};
+struct DipswInstance : public IoDeviceInstance {};
 
 static std::int64_t dipsw_instance_ioctl(IoDeviceInstance *instance,
                                          std::uint64_t request, void *argp) {
@@ -26,7 +24,6 @@ static std::int64_t dipsw_instance_ioctl(IoDeviceInstance *instance,
     return 0;
   }
 
-
   // 0x8010880a
   if (request == 0x8010880a) { // write data? used on initilization
     struct Args {
@@ -36,13 +33,14 @@ static std::int64_t dipsw_instance_ioctl(IoDeviceInstance *instance,
 
     auto args = reinterpret_cast<Args *>(argp);
 
-    std::fprintf(stderr, "dipsw ioctl 0x8010880a(0x%lx, 0x%lx)\n", args->address, args->size);
+    std::fprintf(stderr, "dipsw ioctl 0x8010880a(0x%lx, 0x%lx)\n",
+                 args->address, args->size);
 
     return 0;
   }
 
   std::fprintf(stderr, "***ERROR*** Unhandled dipsw ioctl %lx\n", request);
-   std::fflush(stdout);
+  std::fflush(stdout);
   //__builtin_trap();
   return 0;
 }
diff --git a/rpcsx-os/iodev/dmem.cpp b/rpcsx-os/iodev/dmem.cpp
index d94e85012..891571675 100644
--- a/rpcsx-os/iodev/dmem.cpp
+++ b/rpcsx-os/iodev/dmem.cpp
@@ -1,8 +1,8 @@
 #include "io-device.hpp"
 #include "orbis/KernelAllocator.hpp"
+#include "vm.hpp"
 #include <cinttypes>
 #include <cstdio>
-#include "vm.hpp"
 
 struct DmemDevice : public IoDevice {
   int index;
@@ -71,14 +71,15 @@ static std::int64_t dmem_instance_ioctl(IoDeviceInstance *instance,
     std::fprintf(
         stderr, "TODO: dmem%u releaseDirectMemory(address=0x%lx, size=0x%lx)\n",
         device->index, args->address, args->size);
-    //std::fflush(stdout);
+    // std::fflush(stdout);
     //__builtin_trap();
     return 0;
   }
 
   default:
     std::fprintf(stderr, "***ERROR*** Unhandled dmem%u ioctl %lx\n",
-                 static_cast<DmemDevice *>(instance->device.get())->index, request);
+                 static_cast<DmemDevice *>(instance->device.get())->index,
+                 request);
 
     return 0;
 
@@ -97,8 +98,8 @@ static void *dmem_instance_mmap(IoDeviceInstance *instance, void *address,
                offset, device->memBeginAddress + offset);
 
   auto addr =
-      rx::vm::map(reinterpret_cast<void *>(device->memBeginAddress + offset), size,
-               prot, flags);
+      rx::vm::map(reinterpret_cast<void *>(device->memBeginAddress + offset),
+                  size, prot, flags);
   return addr;
 }
 
diff --git a/rpcsx-os/iodev/gc.cpp b/rpcsx-os/iodev/gc.cpp
index 7b7ac1c98..6fb8a9c7a 100644
--- a/rpcsx-os/iodev/gc.cpp
+++ b/rpcsx-os/iodev/gc.cpp
@@ -113,7 +113,7 @@ static std::int64_t gc_instance_ioctl(IoDeviceInstance *instance,
       rx::bridge.sendCommandBuffer(cmdId, address, size);
     }
 
-    //orbis::bridge.sendDoFlip();
+    // orbis::bridge.sendDoFlip();
     break;
   }
 
@@ -209,11 +209,11 @@ static std::int64_t gc_instance_ioctl(IoDeviceInstance *instance,
     };
 
     auto args = reinterpret_cast<Args *>(argp);
-    std::fprintf(stderr,
-                 "gc ioctl ding dong for workload(pipeHi=%x, pipeLo=%x, queueId=%x, "
-                 "nextStartOffsetInDw=%x)\n",
-                 args->pipeHi, args->pipeLo, args->queueId, args->nextStartOffsetInDw);
-
+    std::fprintf(
+        stderr,
+        "gc ioctl ding dong for workload(pipeHi=%x, pipeLo=%x, queueId=%x, "
+        "nextStartOffsetInDw=%x)\n",
+        args->pipeHi, args->pipeLo, args->queueId, args->nextStartOffsetInDw);
 
     // TODO: implement
 
@@ -222,12 +222,14 @@ static std::int64_t gc_instance_ioctl(IoDeviceInstance *instance,
 
   case 0xc0048114: {
     // SetWaveLimitMultipliers
-    std::fprintf(stderr, "***WARNING*** Unknown gc ioctl_%lx(0x%lx)\n", request, (unsigned long)*(std::uint32_t *)argp);
+    std::fprintf(stderr, "***WARNING*** Unknown gc ioctl_%lx(0x%lx)\n", request,
+                 (unsigned long)*(std::uint32_t *)argp);
     break;
   }
 
   case 0xc004811f: {
-    std::fprintf(stderr, "***WARNING*** Unknown gc ioctl_%lx(0x%lx)\n", request, (unsigned long)*(std::uint32_t *)argp);
+    std::fprintf(stderr, "***WARNING*** Unknown gc ioctl_%lx(0x%lx)\n", request,
+                 (unsigned long)*(std::uint32_t *)argp);
     break;
   }
 
diff --git a/rpcsx-os/iodev/hid.cpp b/rpcsx-os/iodev/hid.cpp
index dee41fc88..3194bb439 100644
--- a/rpcsx-os/iodev/hid.cpp
+++ b/rpcsx-os/iodev/hid.cpp
@@ -9,7 +9,8 @@ struct HidInstance : public IoDeviceInstance {};
 
 static std::int64_t hid_instance_ioctl(IoDeviceInstance *instance,
                                        std::uint64_t request, void *argp) {
-  std::fprintf(stderr, "***ERROR*** Unhandled hid ioctl %" PRIx64 "\n", request);
+  std::fprintf(stderr, "***ERROR*** Unhandled hid ioctl %" PRIx64 "\n",
+               request);
 
   // 0x800c4802
   return 0;
@@ -23,7 +24,7 @@ static void *hid_instance_mmap(IoDeviceInstance *instance, void *address,
 }
 
 static std::int32_t hid_device_open(IoDevice *device,
-                                    orbis::Ref<IoDeviceInstance>  *instance,
+                                    orbis::Ref<IoDeviceInstance> *instance,
                                     const char *path, std::uint32_t flags,
                                     std::uint32_t mode) {
   auto *newInstance = orbis::knew<HidInstance>();
diff --git a/rpcsx-os/iodev/hmd_3da.cpp b/rpcsx-os/iodev/hmd_3da.cpp
index 7043929e3..a3686a151 100644
--- a/rpcsx-os/iodev/hmd_3da.cpp
+++ b/rpcsx-os/iodev/hmd_3da.cpp
@@ -2,17 +2,14 @@
 #include "orbis/KernelAllocator.hpp"
 #include <cstdio>
 
-struct Hmd3daDevice : public IoDevice {
-};
+struct Hmd3daDevice : public IoDevice {};
 
-struct Hmd3daInstance : public IoDeviceInstance {
-};
+struct Hmd3daInstance : public IoDeviceInstance {};
 
 static std::int64_t hmd_3da_instance_ioctl(IoDeviceInstance *instance,
                                            std::uint64_t request, void *argp) {
 
-  std::fprintf(stderr, "***ERROR*** Unhandled hmd_3da ioctl %lx\n",
-        request);
+  std::fprintf(stderr, "***ERROR*** Unhandled hmd_3da ioctl %lx\n", request);
   return -1;
 }
 
diff --git a/rpcsx-os/iodev/hmd_cmd.cpp b/rpcsx-os/iodev/hmd_cmd.cpp
index bf7dcd2e9..6be696283 100644
--- a/rpcsx-os/iodev/hmd_cmd.cpp
+++ b/rpcsx-os/iodev/hmd_cmd.cpp
@@ -2,17 +2,14 @@
 #include "orbis/KernelAllocator.hpp"
 #include <cstdio>
 
-struct HmdCmdDevice : public IoDevice {
-};
+struct HmdCmdDevice : public IoDevice {};
 
-struct HmdCmdInstance : public IoDeviceInstance {
-};
+struct HmdCmdInstance : public IoDeviceInstance {};
 
 static std::int64_t hmd_cmd_instance_ioctl(IoDeviceInstance *instance,
                                            std::uint64_t request, void *argp) {
 
-  std::fprintf(stderr, "***ERROR*** Unhandled hmd_cmd ioctl %lx\n",
-        request);
+  std::fprintf(stderr, "***ERROR*** Unhandled hmd_cmd ioctl %lx\n", request);
   return -1;
 }
 
diff --git a/rpcsx-os/iodev/hmd_mmap.cpp b/rpcsx-os/iodev/hmd_mmap.cpp
index d7666655a..506e4e92a 100644
--- a/rpcsx-os/iodev/hmd_mmap.cpp
+++ b/rpcsx-os/iodev/hmd_mmap.cpp
@@ -6,30 +6,26 @@
 
 struct HmdMmapDevice : public IoDevice {};
 
-struct HmdMmapInstance : public IoDeviceInstance {
-};
+struct HmdMmapInstance : public IoDeviceInstance {};
 
 static std::int64_t hmd_mmap_instance_ioctl(IoDeviceInstance *instance,
                                             std::uint64_t request, void *argp) {
 
-  std::fprintf(stderr, "***ERROR*** Unhandled hmd_mmap ioctl %lx\n",
-        request);
+  std::fprintf(stderr, "***ERROR*** Unhandled hmd_mmap ioctl %lx\n", request);
   std::fflush(stdout);
   __builtin_trap();
   return -1;
 }
 
-static void * hmd_mmap_instance_mmap(IoDeviceInstance *instance,
-                                           void *address, std::uint64_t size,
-                                           std::int32_t prot,
-                                           std::int32_t flags,
-                                           std::int64_t offset) {
+static void *hmd_mmap_instance_mmap(IoDeviceInstance *instance, void *address,
+                                    std::uint64_t size, std::int32_t prot,
+                                    std::int32_t flags, std::int64_t offset) {
   std::fprintf(stderr, "***ERROR*** Unhandled hmd_mmap mmap %lx\n", offset);
   return rx::vm::map(address, size, prot, flags);
 }
 
 static std::int32_t hmd_mmap_device_open(IoDevice *device,
-                                         orbis::Ref<IoDeviceInstance>  *instance,
+                                         orbis::Ref<IoDeviceInstance> *instance,
                                          const char *path, std::uint32_t flags,
                                          std::uint32_t mode) {
   auto *newInstance = orbis::knew<HmdMmapInstance>();
diff --git a/rpcsx-os/iodev/hmd_snsr.cpp b/rpcsx-os/iodev/hmd_snsr.cpp
index 6ae0d3875..3d6761986 100644
--- a/rpcsx-os/iodev/hmd_snsr.cpp
+++ b/rpcsx-os/iodev/hmd_snsr.cpp
@@ -4,19 +4,17 @@
 
 struct HmdSnsrDevice : public IoDevice {};
 
-struct HmdSnsrInstance : public IoDeviceInstance {
-};
+struct HmdSnsrInstance : public IoDeviceInstance {};
 
 static std::int64_t smd_snr_instance_ioctl(IoDeviceInstance *instance,
                                            std::uint64_t request, void *argp) {
 
-  std::fprintf(stderr, "***ERROR*** Unhandled hmd_snsr ioctl %lx\n",
-        request);
+  std::fprintf(stderr, "***ERROR*** Unhandled hmd_snsr ioctl %lx\n", request);
   return -1;
 }
 
 static std::int32_t smd_snr_device_open(IoDevice *device,
-                                        orbis::Ref<IoDeviceInstance>  *instance,
+                                        orbis::Ref<IoDeviceInstance> *instance,
                                         const char *path, std::uint32_t flags,
                                         std::uint32_t mode) {
   auto *newInstance = orbis::knew<HmdSnsrInstance>();
diff --git a/rpcsx-os/iodev/null.cpp b/rpcsx-os/iodev/null.cpp
index 3eae1f622..d55964182 100644
--- a/rpcsx-os/iodev/null.cpp
+++ b/rpcsx-os/iodev/null.cpp
@@ -3,17 +3,17 @@
 
 struct NullDevice : public IoDevice {};
 
-struct NullInstance : public IoDeviceInstance {
-};
+struct NullInstance : public IoDeviceInstance {};
 
 static std::int64_t null_instance_write(IoDeviceInstance *instance,
                                         const void *data, std::uint64_t size) {
   return size;
 }
 
-static std::int32_t null_device_open(IoDevice *device, orbis::Ref<IoDeviceInstance>  *instance,
-                              const char *path, std::uint32_t flags,
-                              std::uint32_t mode) {
+static std::int32_t null_device_open(IoDevice *device,
+                                     orbis::Ref<IoDeviceInstance> *instance,
+                                     const char *path, std::uint32_t flags,
+                                     std::uint32_t mode) {
   auto *newInstance = orbis::knew<NullInstance>();
   newInstance->write = null_instance_write;
 
diff --git a/rpcsx-os/iodev/rng.cpp b/rpcsx-os/iodev/rng.cpp
index f28875779..95edc452a 100644
--- a/rpcsx-os/iodev/rng.cpp
+++ b/rpcsx-os/iodev/rng.cpp
@@ -9,7 +9,8 @@ struct RngInstance : public IoDeviceInstance {};
 
 static std::int64_t rng_instance_ioctl(IoDeviceInstance *instance,
                                        std::uint64_t request, void *argp) {
-  std::fprintf(stderr, "***ERROR*** Unhandled rng ioctl %" PRIx64 "\n", request);
+  std::fprintf(stderr, "***ERROR*** Unhandled rng ioctl %" PRIx64 "\n",
+               request);
   return 0;
 }
 
diff --git a/rpcsx-os/iodev/stderr.cpp b/rpcsx-os/iodev/stderr.cpp
index 7b0fd02d5..b0d986a37 100644
--- a/rpcsx-os/iodev/stderr.cpp
+++ b/rpcsx-os/iodev/stderr.cpp
@@ -8,7 +8,9 @@ struct StderrDevice : public IoDevice {
   StderrInstance *instance = nullptr;
 };
 
-static std::int64_t stderr_instance_write(IoDeviceInstance *instance, const void *data, std::uint64_t size) {
+static std::int64_t stderr_instance_write(IoDeviceInstance *instance,
+                                          const void *data,
+                                          std::uint64_t size) {
   auto result = fwrite(data, 1, size, stderr);
   fflush(stderr);
 
diff --git a/rpcsx-os/iodev/stdin.cpp b/rpcsx-os/iodev/stdin.cpp
index d497c0774..c619aa33c 100644
--- a/rpcsx-os/iodev/stdin.cpp
+++ b/rpcsx-os/iodev/stdin.cpp
@@ -1,18 +1,17 @@
 #include "io-device.hpp"
 #include "orbis/KernelAllocator.hpp"
 
-struct StdinDevice : public IoDevice {
-};
+struct StdinDevice : public IoDevice {};
 
-struct StdinInstance : public IoDeviceInstance {
-};
+struct StdinInstance : public IoDeviceInstance {};
 
 static std::int64_t stdin_instance_read(IoDeviceInstance *instance, void *data,
-                         std::uint64_t size) {
+                                        std::uint64_t size) {
   return -1;
 }
 
-static std::int32_t open(IoDevice *device, orbis::Ref<IoDeviceInstance> *instance,
+static std::int32_t open(IoDevice *device,
+                         orbis::Ref<IoDeviceInstance> *instance,
                          const char *path, std::uint32_t flags,
                          std::uint32_t mode) {
   auto *newInstance = orbis::knew<StdinInstance>();
diff --git a/rpcsx-os/iodev/stdout.cpp b/rpcsx-os/iodev/stdout.cpp
index 0e42709fe..d28391564 100644
--- a/rpcsx-os/iodev/stdout.cpp
+++ b/rpcsx-os/iodev/stdout.cpp
@@ -2,7 +2,6 @@
 #include "orbis/KernelAllocator.hpp"
 #include <cstdio>
 
-
 struct StdoutInstance : public IoDeviceInstance {};
 
 struct StdoutDevice : public IoDevice {
diff --git a/rpcsx-os/iodev/zero.cpp b/rpcsx-os/iodev/zero.cpp
index 1d8bb42c5..fa23769b5 100644
--- a/rpcsx-os/iodev/zero.cpp
+++ b/rpcsx-os/iodev/zero.cpp
@@ -2,11 +2,9 @@
 #include "orbis/KernelAllocator.hpp"
 #include <cstring>
 
-struct ZeroDevice : public IoDevice {
-};
+struct ZeroDevice : public IoDevice {};
 
-struct ZeroInstance : public IoDeviceInstance {
-};
+struct ZeroInstance : public IoDeviceInstance {};
 
 static std::int64_t zero_device_read(IoDeviceInstance *instance, void *data,
                                      std::uint64_t size) {
@@ -15,7 +13,7 @@ static std::int64_t zero_device_read(IoDeviceInstance *instance, void *data,
 }
 
 static std::int32_t zero_device_open(IoDevice *device,
-                                     orbis::Ref<IoDeviceInstance>  *instance,
+                                     orbis::Ref<IoDeviceInstance> *instance,
                                      const char *path, std::uint32_t flags,
                                      std::uint32_t mode) {
   auto *newInstance = orbis::knew<ZeroInstance>();
diff --git a/rpcsx-os/linker.cpp b/rpcsx-os/linker.cpp
index bd936e798..a5da09a31 100644
--- a/rpcsx-os/linker.cpp
+++ b/rpcsx-os/linker.cpp
@@ -574,7 +574,8 @@ Ref<orbis::Module> rx::linker::loadModule(std::span<std::byte> image,
       }
 
       if (dyn.d_tag == kElfDynamicTypeSoName) {
-        auto name = patchSoName(sceStrtab + static_cast<std::uint32_t>(dyn.d_un.d_val));
+        auto name =
+            patchSoName(sceStrtab + static_cast<std::uint32_t>(dyn.d_un.d_val));
         std::memcpy(result->soName, name.data(), name.size());
         std::memcpy(result->soName + name.size(), ".prx", sizeof(".prx"));
       }
diff --git a/rpcsx-os/linker.hpp b/rpcsx-os/linker.hpp
index 6f76d877d..5f6fcaa52 100644
--- a/rpcsx-os/linker.hpp
+++ b/rpcsx-os/linker.hpp
@@ -15,14 +15,14 @@ constexpr std::optional<std::uint64_t> decodeNid(std::string_view nid) {
   std::uint64_t result = 0;
 
   if (nid.size() > 11) {
-    return{};
+    return {};
   }
 
   for (std::size_t i = 0; i < nid.size(); ++i) {
     auto it = std::strchr(nidLookup, nid[i]);
 
     if (it == nullptr) {
-      return{};
+      return {};
     }
 
     auto value = static_cast<uint32_t>(it - nidLookup);
@@ -73,8 +73,12 @@ enum OrbisElfType_t {
   kElfTypeSceDynamic = 0xfe18
 };
 
-void override(std::string originalModuleName, std::filesystem::path replacedModulePath);
-orbis::Ref<orbis::Module> loadModule(std::span<std::byte> image, orbis::Process *process);
-orbis::Ref<orbis::Module> loadModuleFile(const char *path, orbis::Process *process);
-orbis::Ref<orbis::Module> loadModuleByName(std::string_view name, orbis::Process *process);
-} // namespace re::loader
+void override(std::string originalModuleName,
+              std::filesystem::path replacedModulePath);
+orbis::Ref<orbis::Module> loadModule(std::span<std::byte> image,
+                                     orbis::Process *process);
+orbis::Ref<orbis::Module> loadModuleFile(const char *path,
+                                         orbis::Process *process);
+orbis::Ref<orbis::Module> loadModuleByName(std::string_view name,
+                                           orbis::Process *process);
+} // namespace rx::linker
diff --git a/rpcsx-os/main.cpp b/rpcsx-os/main.cpp
index ab784d992..a50831e25 100644
--- a/rpcsx-os/main.cpp
+++ b/rpcsx-os/main.cpp
@@ -5,9 +5,9 @@
 #include "io-devices.hpp"
 #include "linker.hpp"
 #include "ops.hpp"
+#include "thread.hpp"
 #include "vfs.hpp"
 #include "vm.hpp"
-#include "thread.hpp"
 
 #include <filesystem>
 #include <linux/limits.h>
@@ -164,21 +164,22 @@ handle_signal(int sig, siginfo_t *info, void *ucontext) {
   if (sig != SIGINT) {
     char buf[128] = "";
     int len = snprintf(buf, sizeof(buf), " [%s] %u: Signal address=%p\n",
-                      rx::thread::g_current ? "guest" : "host",
-                      rx::thread::g_current ? rx::thread::g_current->tid : ::gettid(),
-                      info->si_addr);
+                       rx::thread::g_current ? "guest" : "host",
+                       rx::thread::g_current ? rx::thread::g_current->tid
+                                             : ::gettid(),
+                       info->si_addr);
     write(2, buf, len);
 
-    if (std::size_t printed = printAddressLocation(
-            buf, sizeof(buf), rx::thread::g_current, (std::uint64_t)info->si_addr)) {
+    if (std::size_t printed =
+            printAddressLocation(buf, sizeof(buf), rx::thread::g_current,
+                                 (std::uint64_t)info->si_addr)) {
       printed += std::snprintf(buf + printed, sizeof(buf) - printed, "\n");
       write(2, buf, printed);
     }
 
-
     if (rx::thread::g_current) {
-      printStackTrace(reinterpret_cast<ucontext_t *>(ucontext), rx::thread::g_current,
-                      2);
+      printStackTrace(reinterpret_cast<ucontext_t *>(ucontext),
+                      rx::thread::g_current, 2);
     } else {
       printStackTrace(reinterpret_cast<ucontext_t *>(ucontext), 2);
     }
@@ -219,7 +220,7 @@ static void setupSigHandlers() {
     exit(EXIT_FAILURE);
   }
 
-  struct sigaction act{};
+  struct sigaction act {};
   act.sa_sigaction = handle_signal;
   act.sa_flags = SA_SIGINFO | SA_ONSTACK;
 
@@ -254,7 +255,6 @@ static void setupSigHandlers() {
   }
 }
 
-
 struct StackWriter {
   std::uint64_t address;
 
@@ -357,9 +357,9 @@ static int ps4Exec(orbis::Process *mainProcess,
   auto stackStartAddress = stackEndAddress - stackSize;
   mainThread->stackStart =
       rx::vm::map(reinterpret_cast<void *>(stackStartAddress), stackSize,
-               rx::vm::kMapProtCpuWrite | rx::vm::kMapProtCpuRead,
-               rx::vm::kMapFlagAnonymous | rx::vm::kMapFlagFixed |
-                   rx::vm::kMapFlagPrivate | rx::vm::kMapFlagStack);
+                  rx::vm::kMapProtCpuWrite | rx::vm::kMapProtCpuRead,
+                  rx::vm::kMapFlagAnonymous | rx::vm::kMapFlagFixed |
+                      rx::vm::kMapFlagPrivate | rx::vm::kMapFlagStack);
 
   mainThread->stackEnd =
       reinterpret_cast<std::byte *>(mainThread->stackStart) + stackSize;
@@ -444,9 +444,9 @@ static int ps4Exec(orbis::Process *mainProcess,
   context->uc_mcontext.gregs[REG_RSP] = sp;
 
   // FIXME: should be at guest user space
-  context->uc_mcontext.gregs[REG_RDX] = reinterpret_cast<std::uint64_t>(+[] {
-    std::printf("At exit\n");
-  });;
+  context->uc_mcontext.gregs[REG_RDX] =
+      reinterpret_cast<std::uint64_t>(+[] { std::printf("At exit\n"); });
+  ;
   context->uc_mcontext.gregs[REG_RIP] = libkernel->entryPoint;
 
   mainThread->context = context;
@@ -458,7 +458,8 @@ static void usage(const char *argv0) {
   std::printf("%s [<options>...] <virtual path to elf> [args...]\n", argv0);
   std::printf("  options:\n");
   std::printf("    -m, --mount <host path> <virtual path>\n");
-  std::printf("    -o, --override <original module name> <virtual path to overriden module>\n");
+  std::printf("    -o, --override <original module name> <virtual path to "
+              "overriden module>\n");
   std::printf("    --trace\n");
 }
 
@@ -488,15 +489,18 @@ static bool isRpsxGpuPid(int pid) {
 
   path[len] = 0;
 
-  std::printf("filename is '%s'\n", std::filesystem::path(path).filename().c_str());
+  std::printf("filename is '%s'\n",
+              std::filesystem::path(path).filename().c_str());
 
   return std::filesystem::path(path).filename() == "rpcsx-gpu";
 }
 static void runRpsxGpu() {
   const char *cmdBufferName = "/rpcsx-gpu-cmds";
-  amdgpu::bridge::BridgeHeader *bridgeHeader = amdgpu::bridge::openShmCommandBuffer(cmdBufferName);
+  amdgpu::bridge::BridgeHeader *bridgeHeader =
+      amdgpu::bridge::openShmCommandBuffer(cmdBufferName);
 
-  if (bridgeHeader != nullptr && bridgeHeader->pullerPid > 0 && isRpsxGpuPid(bridgeHeader->pullerPid)) {
+  if (bridgeHeader != nullptr && bridgeHeader->pullerPid > 0 &&
+      isRpsxGpuPid(bridgeHeader->pullerPid)) {
     bridgeHeader->pusherPid = ::getpid();
     g_gpuPid = bridgeHeader->pullerPid;
     rx::bridge = bridgeHeader;
@@ -561,7 +565,8 @@ int main(int argc, const char *argv[]) {
         return 1;
       }
 
-      rx::vfs::mount(argv[argIndex + 2], createHostIoDevice(argv[argIndex + 1]));
+      rx::vfs::mount(argv[argIndex + 2],
+                     createHostIoDevice(argv[argIndex + 1]));
       argIndex += 3;
       continue;
     }
@@ -585,7 +590,6 @@ int main(int argc, const char *argv[]) {
       continue;
     }
 
-
     break;
   }
 
diff --git a/rpcsx-os/ops.cpp b/rpcsx-os/ops.cpp
index af2e4707e..1e1824e49 100644
--- a/rpcsx-os/ops.cpp
+++ b/rpcsx-os/ops.cpp
@@ -374,7 +374,8 @@ orbis::SysResult dynlib_dlsym(orbis::Thread *thread, orbis::ModuleHandle handle,
     return ErrorCode::INVAL;
   }
 
-  std::printf("sys_dynlib_dlsym(%s (%s), '%s')\n", module->soName, module->moduleName, symbol);
+  std::printf("sys_dynlib_dlsym(%s (%s), '%s')\n", module->soName,
+              module->moduleName, symbol);
 
   std::string_view symView(symbol);
 
@@ -385,7 +386,9 @@ orbis::SysResult dynlib_dlsym(orbis::Thread *thread, orbis::ModuleHandle handle,
     }
   }
 
-  std::printf("sys_dynlib_dlsym(%s (%s), '%s')\n", module->soName, module->moduleName, rx::linker::encodeNid(rx::linker::encodeFid(symView)).string);
+  std::printf("sys_dynlib_dlsym(%s (%s), '%s')\n", module->soName,
+              module->moduleName,
+              rx::linker::encodeNid(rx::linker::encodeFid(symView)).string);
 
   if (auto addr = findSymbolById(module, rx::linker::encodeFid(symView))) {
     *addrp = addr;
@@ -444,27 +447,30 @@ SysResult thr_new(orbis::Thread *thread, orbis::ptr<thr_param> param,
 
   std::printf("Starting child thread %lu\n", (long)(proc->pid + baseId));
 
-  std::thread {
-    [=, childThread = Ref<Thread>(childThread)] {
-      uwrite(_param.child_tid, slong(childThread->tid));
-      auto context = new ucontext_t{};
+  std::thread{[=, childThread = Ref<Thread>(childThread)] {
+    uwrite(_param.child_tid, slong(childThread->tid));
+    auto context = new ucontext_t{};
 
-      context->uc_mcontext.gregs[REG_RDI] = reinterpret_cast<std::uintptr_t>(_param.arg);
-      context->uc_mcontext.gregs[REG_RSI] = reinterpret_cast<std::uintptr_t>(_param.arg);
-      context->uc_mcontext.gregs[REG_RSP] = reinterpret_cast<std::uintptr_t>(childThread->stackEnd);
-      context->uc_mcontext.gregs[REG_RIP] = reinterpret_cast<std::uintptr_t>(_param.start_func);
+    context->uc_mcontext.gregs[REG_RDI] =
+        reinterpret_cast<std::uintptr_t>(_param.arg);
+    context->uc_mcontext.gregs[REG_RSI] =
+        reinterpret_cast<std::uintptr_t>(_param.arg);
+    context->uc_mcontext.gregs[REG_RSP] =
+        reinterpret_cast<std::uintptr_t>(childThread->stackEnd);
+    context->uc_mcontext.gregs[REG_RIP] =
+        reinterpret_cast<std::uintptr_t>(_param.start_func);
 
-      childThread->context = context;
-      childThread->state = orbis::ThreadState::RUNNING;
-      rx::thread::invoke(childThread.get());
-    }
-  }.detach();
+    childThread->context = context;
+    childThread->state = orbis::ThreadState::RUNNING;
+    rx::thread::invoke(childThread.get());
+  }}.detach();
 
   return {};
 }
 SysResult thr_exit(orbis::Thread *thread, orbis::ptr<orbis::slong> state) {
-  std::printf("Requested exit of thread %u, state %p\n", (unsigned)thread->tid, state);
-  // FIXME: do sys_mtx(WAKE) if state is not null 
+  std::printf("Requested exit of thread %u, state %p\n", (unsigned)thread->tid,
+              state);
+  // FIXME: do sys_mtx(WAKE) if state is not null
 
   // FIXME: implement exit
   while (true) {
diff --git a/rpcsx-os/orbis-kernel-config/orbis-config.hpp b/rpcsx-os/orbis-kernel-config/orbis-config.hpp
index ca50da269..4b093dc3d 100644
--- a/rpcsx-os/orbis-kernel-config/orbis-config.hpp
+++ b/rpcsx-os/orbis-kernel-config/orbis-config.hpp
@@ -4,8 +4,8 @@
 #include "orbis/thread/RegisterId.hpp"
 #include <cstdint>
 #include <cstring>
-#include <sys/ucontext.h>
 #include <immintrin.h>
+#include <sys/ucontext.h>
 
 namespace orbis {
 using int8_t = std::int8_t;
@@ -29,23 +29,24 @@ using slong = int64_t;
 using ulong = uint64_t;
 
 template <typename T> using ptr = T *;
-template <typename T> using cptr = T * const;
+template <typename T> using cptr = T *const;
 
 using caddr_t = ptr<char>;
 
 inline ErrorCode uread(void *kernelAddress, ptr<const void> userAddress,
-                  size_t size) {
+                       size_t size) {
   std::memcpy(kernelAddress, userAddress, size);
   return {};
 }
 
 inline ErrorCode uwrite(ptr<void> userAddress, const void *kernelAddress,
-                   size_t size) {
+                        size_t size) {
   std::memcpy(userAddress, kernelAddress, size);
   return {};
 }
 
-inline ErrorCode ureadString(char *kernelAddress, size_t kernelSize, ptr<const char> userAddress) {
+inline ErrorCode ureadString(char *kernelAddress, size_t kernelSize,
+                             ptr<const char> userAddress) {
   std::strncpy(kernelAddress, userAddress, kernelSize);
   if (kernelAddress[kernelSize - 1] != '\0') {
     kernelAddress[kernelSize - 1] = '\0';
@@ -55,7 +56,6 @@ inline ErrorCode ureadString(char *kernelAddress, size_t kernelSize, ptr<const c
   return {};
 }
 
-
 template <typename T> T uread(ptr<T> pointer) {
   T result;
   uread(&result, pointer, sizeof(T));
@@ -69,46 +69,97 @@ template <typename T> void uwrite(ptr<T> pointer, T data) {
 inline uint64_t readRegister(void *context, RegisterId id) {
   auto c = &reinterpret_cast<ucontext_t *>(context)->uc_mcontext;
   switch (id) {
-  case RegisterId::r15: return c->gregs[REG_R15];
-  case RegisterId::r14: return c->gregs[REG_R14];
-  case RegisterId::r13: return c->gregs[REG_R13];
-  case RegisterId::r12: return c->gregs[REG_R12];
-  case RegisterId::r11: return c->gregs[REG_R11];
-  case RegisterId::r10: return c->gregs[REG_R10];
-  case RegisterId::r9: return c->gregs[REG_R9];
-  case RegisterId::r8: return c->gregs[REG_R8];
-  case RegisterId::rdi: return c->gregs[REG_RDI];
-  case RegisterId::rsi: return c->gregs[REG_RSI];
-  case RegisterId::rbp: return c->gregs[REG_RBP];
-  case RegisterId::rbx: return c->gregs[REG_RBX];
-  case RegisterId::rdx: return c->gregs[REG_RDX];
-  case RegisterId::rcx: return c->gregs[REG_RCX];
-  case RegisterId::rax: return c->gregs[REG_RAX];
-  case RegisterId::rsp: return c->gregs[REG_RSP];
-  case RegisterId::rflags: return c->gregs[REG_EFL];
+  case RegisterId::r15:
+    return c->gregs[REG_R15];
+  case RegisterId::r14:
+    return c->gregs[REG_R14];
+  case RegisterId::r13:
+    return c->gregs[REG_R13];
+  case RegisterId::r12:
+    return c->gregs[REG_R12];
+  case RegisterId::r11:
+    return c->gregs[REG_R11];
+  case RegisterId::r10:
+    return c->gregs[REG_R10];
+  case RegisterId::r9:
+    return c->gregs[REG_R9];
+  case RegisterId::r8:
+    return c->gregs[REG_R8];
+  case RegisterId::rdi:
+    return c->gregs[REG_RDI];
+  case RegisterId::rsi:
+    return c->gregs[REG_RSI];
+  case RegisterId::rbp:
+    return c->gregs[REG_RBP];
+  case RegisterId::rbx:
+    return c->gregs[REG_RBX];
+  case RegisterId::rdx:
+    return c->gregs[REG_RDX];
+  case RegisterId::rcx:
+    return c->gregs[REG_RCX];
+  case RegisterId::rax:
+    return c->gregs[REG_RAX];
+  case RegisterId::rsp:
+    return c->gregs[REG_RSP];
+  case RegisterId::rflags:
+    return c->gregs[REG_EFL];
   }
 }
 
 inline void writeRegister(void *context, RegisterId id, uint64_t value) {
   auto c = &reinterpret_cast<ucontext_t *>(context)->uc_mcontext;
   switch (id) {
-  case RegisterId::r15: c->gregs[REG_R15] = value; return;
-  case RegisterId::r14: c->gregs[REG_R14] = value; return;
-  case RegisterId::r13: c->gregs[REG_R13] = value; return;
-  case RegisterId::r12: c->gregs[REG_R12] = value; return;
-  case RegisterId::r11: c->gregs[REG_R11] = value; return;
-  case RegisterId::r10: c->gregs[REG_R10] = value; return;
-  case RegisterId::r9: c->gregs[REG_R9] = value; return;
-  case RegisterId::r8: c->gregs[REG_R8] = value; return;
-  case RegisterId::rdi: c->gregs[REG_RDI] = value; return;
-  case RegisterId::rsi: c->gregs[REG_RSI] = value; return;
-  case RegisterId::rbp: c->gregs[REG_RBP] = value; return;
-  case RegisterId::rbx: c->gregs[REG_RBX] = value; return;
-  case RegisterId::rdx: c->gregs[REG_RDX] = value; return;
-  case RegisterId::rcx: c->gregs[REG_RCX] = value; return;
-  case RegisterId::rax: c->gregs[REG_RAX] = value; return;
-  case RegisterId::rsp: c->gregs[REG_RSP] = value; return;
-  case RegisterId::rflags: c->gregs[REG_EFL] = value; return;
+  case RegisterId::r15:
+    c->gregs[REG_R15] = value;
+    return;
+  case RegisterId::r14:
+    c->gregs[REG_R14] = value;
+    return;
+  case RegisterId::r13:
+    c->gregs[REG_R13] = value;
+    return;
+  case RegisterId::r12:
+    c->gregs[REG_R12] = value;
+    return;
+  case RegisterId::r11:
+    c->gregs[REG_R11] = value;
+    return;
+  case RegisterId::r10:
+    c->gregs[REG_R10] = value;
+    return;
+  case RegisterId::r9:
+    c->gregs[REG_R9] = value;
+    return;
+  case RegisterId::r8:
+    c->gregs[REG_R8] = value;
+    return;
+  case RegisterId::rdi:
+    c->gregs[REG_RDI] = value;
+    return;
+  case RegisterId::rsi:
+    c->gregs[REG_RSI] = value;
+    return;
+  case RegisterId::rbp:
+    c->gregs[REG_RBP] = value;
+    return;
+  case RegisterId::rbx:
+    c->gregs[REG_RBX] = value;
+    return;
+  case RegisterId::rdx:
+    c->gregs[REG_RDX] = value;
+    return;
+  case RegisterId::rcx:
+    c->gregs[REG_RCX] = value;
+    return;
+  case RegisterId::rax:
+    c->gregs[REG_RAX] = value;
+    return;
+  case RegisterId::rsp:
+    c->gregs[REG_RSP] = value;
+    return;
+  case RegisterId::rflags:
+    c->gregs[REG_EFL] = value;
+    return;
   }
 }
 
diff --git a/rpcsx-os/thread.hpp b/rpcsx-os/thread.hpp
index 467ad4e45..74452e9fd 100644
--- a/rpcsx-os/thread.hpp
+++ b/rpcsx-os/thread.hpp
@@ -8,4 +8,4 @@ void deinitialize();
 
 extern thread_local orbis::Thread *g_current;
 void invoke(orbis::Thread *thread);
-}
+} // namespace rx::thread
diff --git a/rpcsx-os/vfs.cpp b/rpcsx-os/vfs.cpp
index b3bf2cc21..00dd94627 100644
--- a/rpcsx-os/vfs.cpp
+++ b/rpcsx-os/vfs.cpp
@@ -11,11 +11,10 @@
 static std::map<std::string, orbis::Ref<IoDevice>> sMountsMap;
 
 void rx::vfs::initialize() {}
-void rx::vfs::deinitialize() {
-  sMountsMap.clear();
-}
+void rx::vfs::deinitialize() { sMountsMap.clear(); }
 
-orbis::SysResult rx::vfs::mount(const std::filesystem::path &guestPath, IoDevice *dev) {
+orbis::SysResult rx::vfs::mount(const std::filesystem::path &guestPath,
+                                IoDevice *dev) {
   auto [it, inserted] =
       sMountsMap.emplace(guestPath.lexically_normal().string(), dev);
 
@@ -27,7 +26,7 @@ orbis::SysResult rx::vfs::mount(const std::filesystem::path &guestPath, IoDevice
 }
 
 orbis::SysResult rx::vfs::open(std::string_view path, int flags, int mode,
-                           orbis::Ref<IoDeviceInstance> *instance) {
+                               orbis::Ref<IoDeviceInstance> *instance) {
   orbis::Ref<IoDevice> device;
   bool isCharacterDevice = path.starts_with("/dev/");
 
diff --git a/rpcsx-os/vfs.hpp b/rpcsx-os/vfs.hpp
index 735c2d8d3..277ada361 100644
--- a/rpcsx-os/vfs.hpp
+++ b/rpcsx-os/vfs.hpp
@@ -13,4 +13,4 @@ void deinitialize();
 orbis::SysResult mount(const std::filesystem::path &guestPath, IoDevice *dev);
 orbis::SysResult open(std::string_view path, int flags, int mode,
                       orbis::Ref<IoDeviceInstance> *instance);
-} // namespace vfs
+} // namespace rx::vfs
diff --git a/rpcsx-os/vm.cpp b/rpcsx-os/vm.cpp
index 938828339..7be84ebff 100644
--- a/rpcsx-os/vm.cpp
+++ b/rpcsx-os/vm.cpp
@@ -591,8 +591,8 @@ static void reserve(std::uint64_t startAddress, std::uint64_t endAddress) {
   assert(blockIndex == (endAddress >> kBlockShift));
 
   auto firstPage = (startAddress & kBlockMask) >> rx::vm::kPageShift;
-  auto pagesCount =
-      (endAddress - startAddress + (rx::vm::kPageSize - 1)) >> rx::vm::kPageShift;
+  auto pagesCount = (endAddress - startAddress + (rx::vm::kPageSize - 1)) >>
+                    rx::vm::kPageShift;
 
   gBlocks[blockIndex - kFirstBlock].setFlags(firstPage, pagesCount, kAllocated);
 }
@@ -600,7 +600,8 @@ static void reserve(std::uint64_t startAddress, std::uint64_t endAddress) {
 void rx::vm::initialize() {
   std::printf("Memory: initialization\n");
 
-  gMemoryShm = ::shm_open("/rpcsx-os-memory", O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
+  gMemoryShm =
+      ::shm_open("/rpcsx-os-memory", O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
 
   if (gMemoryShm == -1) {
     std::printf("Memory: failed to open /rpcsx-os-memory\n");
@@ -614,7 +615,8 @@ void rx::vm::initialize() {
 
   reserve(0, kMinAddress); // unmapped area
 
-  utils::reserve(reinterpret_cast<void *>(kMinAddress), kMaxAddress - kMinAddress);
+  utils::reserve(reinterpret_cast<void *>(kMinAddress),
+                 kMaxAddress - kMinAddress);
 
   // orbis::bridge.setUpSharedMemory(kMinAddress, kMemorySize, "/orbis-memory");
 }
@@ -853,8 +855,8 @@ bool rx::vm::unmap(void *addr, std::uint64_t size) {
 }
 
 bool rx::vm::protect(void *addr, std::uint64_t size, std::int32_t prot) {
-  std::printf("rx::vm::protect(addr = %p, len = %" PRIu64 ", prot = %s)\n", addr,
-              size, mapProtToString(prot).c_str());
+  std::printf("rx::vm::protect(addr = %p, len = %" PRIu64 ", prot = %s)\n",
+              addr, size, mapProtToString(prot).c_str());
 
   auto pages = (size + (kPageSize - 1)) >> kPageShift;
   auto address = reinterpret_cast<std::uint64_t>(addr);
@@ -880,7 +882,8 @@ bool rx::vm::protect(void *addr, std::uint64_t size, std::int32_t prot) {
       (address & kBlockMask) >> kPageShift, pages,
       kAllocated | (prot & (kMapProtCpuAll | kMapProtGpuAll)));
 
-  rx::bridge.sendMemoryProtect(reinterpret_cast<std::uint64_t>(addr), size, prot);
+  rx::bridge.sendMemoryProtect(reinterpret_cast<std::uint64_t>(addr), size,
+                               prot);
   return ::mprotect(addr, size, prot & kMapProtCpuAll) == 0;
 }
 
diff --git a/rpcsx-os/vm.hpp b/rpcsx-os/vm.hpp
index 74813d879..a7999e20e 100644
--- a/rpcsx-os/vm.hpp
+++ b/rpcsx-os/vm.hpp
@@ -1,6 +1,6 @@
 #pragma once
-#include <cstdint>
 #include <cstddef>
+#include <cstdint>
 #include <string>
 
 namespace rx::vm {
@@ -68,11 +68,12 @@ std::string mapProtToString(std::int32_t prot);
 void printHostStats();
 void initialize();
 void deinitialize();
-void *map(void *addr, std::uint64_t len, std::int32_t prot, std::int32_t flags, std::int32_t internalFlags = 0);
+void *map(void *addr, std::uint64_t len, std::int32_t prot, std::int32_t flags,
+          std::int32_t internalFlags = 0);
 bool unmap(void *addr, std::uint64_t size);
 bool protect(void *addr, std::uint64_t size, std::int32_t prot);
 
 bool virtualQuery(const void *addr, std::int32_t flags, VirtualQueryInfo *info);
 bool queryProtection(const void *addr, std::uint64_t *startAddress,
                      std::uint64_t *endAddress, std::int64_t *prot);
-}
+} // namespace rx::vm